leadlight 0.0.5 → 0.0.6

data/spec/leadlight/link_spec.rb

@@ -3,6 +3,8 @@ require 'leadlight/link'
 
 module Leadlight
   describe Link do
+    include LinkMatchers
+
     subject { Link.new(service, href, rel, title, options) }
     let(:service) { stub(:service, get: nil) }
     let(:href)    { '/TEST_PATH'   }
@@ -10,9 +12,26 @@ module Leadlight
     let(:title)   { 'TEST_TITLE'   }
     let(:options) { {}             }
 
+    it { should expand_to('/TEST_PATH?foo=bar').given(:foo => 'bar') }
+    it {
+      should expand_to('/TEST_PATH?foo=bar&x=42').
+        given(:foo => 'bar', "x" => 42)
+    }
+    it {
+      should expand_to('/TEST_PATH?foo[0]=123&foo[1]=456').
+        given(:foo => [123,456])
+    }
+
+    describe '#expand' do
+      it 'returns self given no arguments' do
+        subject.expand.should equal(subject)
+      end
+    end
+
     describe '#follow' do
       it 'calls service.get with the href' do
-        service.should_receive(:get_representation!).with(Addressable::URI.parse(href))
+        service.should_receive(:get_representation!).
+          with(Addressable::URI.parse(href), anything, anything)
         subject.follow
       end
 
@@ -26,28 +45,69 @@ module Leadlight
       end
     end
 
-    def self.delegates_to_service(method_name)
+    def self.delegates_to_service(method_name, has_body)
       it "delegates ##{method_name} to the service" do
         yielded        = :nothing
         args           = [:foo, :bar]
         request        = stub(:request)
         representation = stub(:representation)
+        if has_body
+          args.unshift nil
+        end
         service.should_receive(method_name).
-          with(subject.href, *args).
+          with(subject.href, nil, :foo, :bar, anything).
           and_yield(representation).
           and_return(request)
         subject.public_send(method_name, *args) do |rep|
           yielded = rep
         end.should equal(request)
       end
+
+      it "adds itself to the options for ##{method_name}" do
+        yielded        = :nothing
+        args           = [:foo, :bar, {baz: "buz"}]
+        request        = stub(:request)
+        representation = stub(:representation)
+        if has_body
+          args.unshift nil
+        end
+        service.should_receive(method_name).
+          with(subject.href, nil, :foo, :bar, {baz: "buz", link: subject})
+        subject.public_send(method_name, *args)
+      end
+
+      it "adds missing request options hash to calls to ##{method_name}" do
+        yielded        = :nothing
+        args           = [:foo, :bar]
+        request        = stub(:request)
+        representation = stub(:representation)
+        if has_body
+          args.unshift nil
+        end
+        service.should_receive(method_name).
+          with(subject.href, nil, :foo, :bar, {link: subject})
+        subject.public_send(method_name, *args)
+      end
     end
 
-    delegates_to_service :get
-    delegates_to_service :post
-    delegates_to_service :head
-    delegates_to_service :options
-    delegates_to_service :put
-    delegates_to_service :delete
-    delegates_to_service :patch
+    #                    method    has_body
+    delegates_to_service :get,     false
+    delegates_to_service :post,    true
+    delegates_to_service :head,    false
+    delegates_to_service :options, false
+    delegates_to_service :put,     true
+    delegates_to_service :delete,  false
+    delegates_to_service :patch,   true
+
+
+    describe '#params' do
+      context 'when explicitly specified' do
+        it 'gives explicit params priority over query params' do
+          href = "/somepath?foo=baz&fizz=buzz"
+          link = Link.new(service, href, rel, title, :expansion_params => {:foo => 'bar'})
+          link.params.should eq('foo' => 'bar', 'fizz' => 'buzz')
+        end
+      end
+    end
   end
 end

data/spec/leadlight/link_template_spec.rb

@@ -5,6 +5,8 @@ require 'leadlight/type_map'
 module Leadlight
   describe LinkTemplate do
 
+    include LinkMatchers
+
     # TODO: This setup is loony. Refactor.
     subject { LinkTemplate.new(service, href, rel, title, options) }
     let(:service) { stub(:service, type_map: TypeMap.new) }
@@ -22,19 +24,33 @@ module Leadlight
       service.stub(:get_representation!).and_yield(result).and_return(request)
     end
 
+    it { should(expand_to('/TEST_PATH/N/M/?foo=bar').
+                with_params('n' => 'N', 'm' => 'M').
+                given(:n => "N", :m => "M", :foo => 'bar'))}
+
+    it { should(expand_to('/TEST_PATH/N/M/?foo=bar&x=42').
+                given(:n => "N", :m => "M", :foo => 'bar', "x" => 42))}
+
+    it { should(expand_to('/TEST_PATH/N/M/?foo[0]=123&foo[1]=456').
+                given(:n => "N", :m => "M", :foo => [123,456])) }
+
     describe '#follow' do
       it 'calls service.get with the expanded href' do
-        service.should_receive(:get_representation!).with('/TEST_PATH/23/42/')
+        service.should_receive(:get_representation!).
+          with(u('/TEST_PATH/23/42/'))
         subject.follow(23,42)
       end
 
       it 'can accept a hash for template parameters' do
-        service.should_receive(:get_representation!).with('/TEST_PATH/AA/BB/')
+        service.should_receive(:get_representation!).
+          with(u('/TEST_PATH/AA/BB/'))
         subject.follow(:n => 'AA', 'm' => 'BB')
       end
 
-      it 'leaves unrecognized params in the params hash alone' do
-        service.should_receive(:get_representation!).with('/TEST_PATH/AA/BB/', {'other' => 'XX'})
+
+      it 'tacks unrecognized on as query params' do
+        service.should_receive(:get_representation!).
+          with(u('/TEST_PATH/AA/BB/?other=XX'))
         subject.follow(:n => 'AA', 'm' => 'BB', :other => 'XX')
       end
 

data/spec/leadlight/null_link_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper_lite'
+require 'leadlight/null_link'
+
+module Leadlight
+  describe NullLink do
+    subject {
+      NullLink.new("http://example.org/z/y/?foo=123&bar=456&bar=789")
+    }
+
+    it 'derives params from URL query string' do
+      subject.params.should eq("foo" => "123", "bar" => "789")
+    end
+  end
+end

data/spec/leadlight/param_hash_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper_lite'
+require 'leadlight/param_hash'
+
+module Leadlight
+  describe ParamHash do
+    include Leadlight
+    it 'converts values to strings' do
+      result = ParamHash(:foo => 123, :bar => :baz, :buz => 2.3)
+      result.should eq({:foo => "123", :bar => "baz", :buz => "2.3"})
+    end
+
+    it 'converts arrays to arrays of strings' do
+      result = ParamHash(:foo => [:bar, 123, 3.14])
+      result.should eq(:foo => ["bar", "123", "3.14"])
+    end
+
+
+    it 'converts values recursively' do
+      result = ParamHash(:h =>
+                         {:foo => 123, :bar => :baz, :buz => 2.3})
+      result.should eq(:h =>
+                       {:foo => "123", :bar => "baz", :buz => "2.3"})
+    end
+
+  end
+end

data/spec/leadlight/representation_spec.rb

@@ -11,6 +11,10 @@ module Leadlight
     let(:service) { stub(:service, tints: [TintA, TintB]) }
     let(:location) { stub(:location) }
     let(:response) { stub(:response) }
+    let(:request_params)   { stub(:request_params)   }
+    let(:link)     { stub(:link)     }
+    let(:request)  { stub(:request, params: request_params, link: link)  }
+    let(:captures) { stub(:captures) }
 
     it 'has a __service__ accessor' do
       subject.__service__ = service
@@ -27,23 +31,51 @@ module Leadlight
       subject.__response__.should equal(response)
     end
 
+    it 'has a __request__ accessor' do
+      subject.__request__ = request
+      subject.__request__.should equal(request)
+    end
+
+    it 'has a __link__ accessor' do
+      subject.__request__ = request
+      subject.__link__.should equal(link)
+    end
+
+    it 'has a __request_params__ accessor' do
+      subject.__request__ = request
+      subject.__request_params__.should equal(request_params)
+    end
+
+    describe '#__captures__' do
+      it 'defaults to an empty hash' do
+        subject.__captures__.should eq({})
+      end
+    end
+
     describe '#initialize_representation' do
-      it 'sets __service__, __location__, and __response__' do
-        subject.initialize_representation(service, location, response)
+      it 'sets __service__, __location__, __response__, and __request__' do
+        subject.initialize_representation(service, location, response, request)
         subject.__service__.should equal(service)
         subject.__location__.should equal(location)
         subject.__response__.should equal(response)
+        subject.__request__.should equal(request)
       end
 
       it 'returns self' do
-        result = subject.initialize_representation(service, location, response)
+        result = subject.initialize_representation(service,
+                                                   location,
+                                                   response,
+                                                   request)
         result.should equal(subject)
       end
 
     end
     describe '#apply_all_tints' do
       before do
-        subject.initialize_representation(service, location, response)
+        subject.initialize_representation(service,
+                                          location,
+                                          response,
+                                          request_params)
       end
 
       it 'extends object with tints from service' do

data/spec/leadlight/request_spec.rb

@@ -47,19 +47,22 @@ module Leadlight
       end
     end
 
-    subject { Request.new(service, connection, url, http_method, params, body) }
+    subject { Request.new(service, connection, url, http_method, body, options) }
     let(:service)    { stub(:service, :type_map => type_map) }
     let(:type_map)   { stub(:type_map).as_null_object }
     let(:connection) { stub(:connection, :run_request => faraday_response) }
-    let(:url)        { stub(:url)        }
+    let(:url)        { stub(:url, :to_s => "STRINGIFIED_URL") }
     let(:http_method){ :get              }
     let(:body)       { stub(:body)       }
-    let(:params)     { {}                }
-    let(:faraday_request) {stub(:faraday_request, options: {})}
+    let(:faraday_request) {stub(:faraday_request, options: {}, params: request_params)}
     let(:on_complete_handlers) { [] }
-    let(:faraday_env)      { {} }
+    let(:faraday_env)      { {request: faraday_request} }
     let(:representation)   { stub(:representation) }
     let(:faraday_response) { FakeFaradayResponse.new(faraday_env) }
+    let(:link)             { stub(:link, params: link_params) }
+    let(:link_params)      { { a: "123", b: "456" } }
+    let(:request_params)   { { b: "789", c: "321" } }
+    let(:options)          { { link: link } }
 
     def run_completion_handlers
       faraday_env[:status]   ||= 200
@@ -107,7 +110,7 @@ module Leadlight
 
       it "starts a request runnning" do
         connection.should_receive(:run_request).
-          with(http_method, url, anything, {}).
+          with(http_method, "STRINGIFIED_URL", anything, {}).
           and_return(faraday_response)
         subject.submit
       end
@@ -121,21 +124,6 @@ module Leadlight
         yielded.should equal(faraday_request)
       end
 
-      context "with request params" do
-        let(:params) {{ query: 'value' }}
-
-        it "passes params to request" do
-          request_params.should_receive(:update).with(params)
-          subject.submit
-        end
-      end
-
-      context "with no request params" do
-        it "doesn't alter request params" do
-          request_params.should_not_receive(:update)
-          subject.submit
-        end
-      end
     end
 
     shared_examples_for "synchronous methods" do
@@ -309,7 +297,36 @@ module Leadlight
         subject.should_receive(:raise).with(representation)
         submit_and_complete
       end
-      
+
+    end
+
+    describe "#link" do
+      it "defaults to a null link with the URL passed in" do
+        subject = Request.new(service, connection, url, http_method, body)
+        subject.link.should eq(NullLink.new(url))
+      end
+
+      it 'is taken from options supplied to constructor' do
+        link = double
+        subject = Request.new(service, connection, url, http_method, body, link: link)
+        subject.link.should be(link)
+      end
+    end
+
+    describe "#params" do
+      context "(after completion)" do
+        def do_it(&block)
+          subject.submit_and_wait(&block)
+        end
+
+        before do
+          do_it_and_complete
+        end
+
+        it 'merges request params and link params' do
+          subject.params.should eq(a: "123", b: "789", c: "321")
+        end
+      end
     end
 
   end

data/spec/leadlight/service_spec.rb

@@ -4,13 +4,13 @@ require 'leadlight/service'
 module Leadlight
   describe Service do
     subject              { klass.new(service_options)                 }
-    let(:klass)          { 
-      Class.new do 
+    let(:klass)          {
+      Class.new do
         include Service
-        
+
         def execute_hook(*)
         end
-      end          
+      end
     }
     let(:connection)     { stub(:connection, get: response)           }
     let(:representation) { stub(:representation)                      }
@@ -22,7 +22,7 @@ module Leadlight
     let(:request_class)  { stub(:request_class, new: request)         }
 
     before do
-      subject.stub(connection: connection, 
+      subject.stub(connection: connection,
                    url: nil,
                    request_class: request_class)
     end
@@ -62,20 +62,21 @@ module Leadlight
           subject.public_send(http_method, '/somepath')
         end
 
-        it 'passes the params to the request' do
-          params = stub
+        it 'passes the body to the request' do
+          body = stub
           request_class.should_receive(:new).
-            with(anything, anything, anything, anything, params, anything).
+            with(anything, anything, anything, anything, body, anything).
             and_return(request)
-          subject.public_send(http_method, '/somepath', params)
+          subject.public_send(http_method, '/somepath', body)
         end
 
-        it 'passes the body to the request' do
-          body = stub
+        it 'passes the originating link to the request' do
+          link = double(:link)
           request_class.should_receive(:new).
-            with(anything, anything, anything, anything, anything, body).
+            with(anything, anything, anything, anything, anything,
+                 hash_including(link: link)).
             and_return(request)
-          subject.public_send(http_method, '/somepath', {}, body)
+          subject.public_send(http_method, '/somepath', anything, link: link)
         end
 
         context 'given a block' do

data/spec/leadlight/tint_helper_spec.rb

@@ -5,8 +5,9 @@ module Leadlight
   describe TintHelper do
     subject{ TintHelper.new(object, tint) }
     let(:object) {
-      stub(__location__: stub(path: '/the/path'),
-           __response__: response)
+      stub(__location__: Addressable::URI.parse('/the/path'),
+           __response__: response,
+           __captures__: captures)
     }
     let(:response) {
       stub(:response,
@@ -18,6 +19,7 @@ module Leadlight
       { 'Content-Type' => 'text/html; charset=UTF-8'}
     }
     let(:tint) { Module.new }
+    let(:captures) { {} }
 
     it 'forwards unknown calls to the wrapped object' do
       object.should_receive(:foo).with('bar')
@@ -41,6 +43,13 @@ module Leadlight
         end
       end
 
+      it 'adds regex captures to representation captures' do
+        subject.exec_tint do
+          match_path(%r{/(?<x>\w+)/(?<y>\w+)})
+        end
+        captures.should eq('x' => 'the', 'y' => 'path')
+      end
+
       it 'does not allow execution to proceed on no match' do
         object.should_not_receive(:baz)
         subject.exec_tint do
@@ -50,6 +59,31 @@ module Leadlight
       end
     end
 
+    describe '#match_template' do
+      it 'allows execution to proceed on match' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_template('/{a}/{b}')
+          baz
+        end
+      end
+
+      it 'halts execution on no match' do
+        object.should_not_receive(:baz)
+        subject.exec_tint do
+          match_template('/{a}/{b}/{c}')
+          baz
+        end
+      end
+
+      it 'adds mappings to representation captures' do
+        subject.exec_tint do
+          match_template('/{a}/{b}')
+        end
+        captures.should eq('a' => 'the', 'b' => 'path')
+      end
+    end
+
     describe '#match_content_type' do
       it 'allows execution to proceed on match' do
         object.should_receive(:baz)