leadlight 0.0.2 → 0.0.3

data/spec/leadlight/hyperlinkable_spec.rb

@@ -23,7 +23,9 @@ module Leadlight
     }
 
     before do
-      representation.stub(__response__: response, __service__: service)
+      representation.stub(__response__: response, 
+                          __service__: service,
+                          __location__: '/foo')
     end
 
     describe '.extend' do

data/spec/leadlight/link_template_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper_lite'
 require 'leadlight/link_template'
+require 'leadlight/type_map'
 
 module Leadlight
   describe LinkTemplate do
 
     # TODO: This setup is loony. Refactor.
     subject { LinkTemplate.new(service, href, rel, title, options) }
-    let(:service) { stub(:service) }
+    let(:service) { stub(:service, type_map: TypeMap.new) }
     let(:request) { stub(:request)               }
     let(:result)  { stub(:result)                }
     let(:href)    { '/TEST_PATH/{n}/{m}/'   }

data/spec/leadlight/request_spec.rb

@@ -6,6 +6,14 @@ module Leadlight
   describe Request do
     include Timeout
 
+    before :all do
+      @old_abort_on_exception = Thread.abort_on_exception
+      Thread.abort_on_exception = true
+    end
+
+    after :all do
+      Thread.abort_on_exception = @old_abort_on_exception
+    end
 
     # The Faraday connection API works like this:
     #
@@ -29,24 +37,34 @@ module Leadlight
 
       def run_completion_handlers(n=1)
         n.times do
-          completion_handlers.pop.call(@env)
+          handler = completion_handlers.pop
+          handler.call(@env)
         end
       end
+
+      def success?
+        true
+      end
     end
 
-    subject { Request.new(connection, url, http_method, params, body) }
+    subject { Request.new(service, connection, url, http_method, params, body) }
+    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(:http_method){ :get              }
     let(:body)       { stub(:body)       }
     let(:params)     { {}                }
-    let(:faraday_request) {stub(:faraday_request)}
+    let(:faraday_request) {stub(:faraday_request, options: {})}
     let(:on_complete_handlers) { [] }
-    let(:faraday_response) { FakeFaradayResponse.new(faraday_env) }
-    let(:faraday_env)      { {:leadlight_representation => representation} }
+    let(:faraday_env)      { {} }
     let(:representation)   { stub(:representation) }
+    let(:faraday_response) { FakeFaradayResponse.new(faraday_env) }
 
     def run_completion_handlers
+      faraday_env[:status]   ||= 200
+      faraday_env[:response] ||= faraday_response
+      faraday_env[:leadlight_representation] ||= representation
       faraday_response.run_completion_handlers
     end
 
@@ -55,7 +73,11 @@ module Leadlight
         do_it(&block)
       end
       run_completion_handlers
-      t.join.value
+      t.join(1).value
+    end
+
+    before do
+      subject.stub!(:represent => representation)
     end
 
     context "for GET" do
@@ -74,17 +96,17 @@ module Leadlight
     describe "#submit" do
       it "starts a request runnning" do
         connection.should_receive(:run_request).
-          with(http_method, url, body, {}).
+          with(http_method, url, anything, {}).
           and_return(faraday_response)
         subject.submit
       end
 
       it "triggers the on_prepare_request hook in the block passed to #run_request" do
         yielded         = :nothing
-        faraday_request = stub
+        faraday_request = stub(options: {}, headers: {})
         connection.stub(:run_request).
           and_yield(faraday_request).
-          and_return(faraday_response)
+          and_return(stub.as_null_object)
         subject.on_prepare_request do |request|
           yielded = request
         end
@@ -103,8 +125,8 @@ module Leadlight
             trace << "wait finished"
           end
           trace << "completing request"
-          faraday_response.run_completion_handlers
-          thread.join
+          run_completion_handlers
+          thread.join(1)
           trace << "request completed"
           trace.pop.should eq("completing request")
           trace.pop.should eq("wait finished")
@@ -125,8 +147,8 @@ module Leadlight
             trace << "submit"
             subject.submit
             trace << "completing request"
-            faraday_response.run_completion_handlers
-            thread.join
+            run_completion_handlers
+            thread.join(1)
             trace << "request completed"
             trace.pop.should eq("submit")
             trace.pop.should eq("completing request")
@@ -181,7 +203,7 @@ module Leadlight
           subject.wait
         end
         run_completion_handlers
-        t.join
+        t.join(1)
       end
 
       it "queues hooks to be run on completion" do
@@ -197,8 +219,6 @@ module Leadlight
       end
 
       it "calls hooks with the faraday response" do
-        Faraday::Response.should_receive(:new).with(faraday_env).
-          and_return(faraday_response)
         yielded = :nothing
         subject.on_complete do |response|
           yielded = response
@@ -216,21 +236,24 @@ module Leadlight
           subject.wait
         end
         run_completion_handlers
-        t.join
+        t.join(1)
         subject
       end
 
       it "raises an error when the response is a client error" do
-        faraday_env[:status] = 404
-        expect { submit_and_complete.raise_on_error }.to raise_error(ResourceNotFound)
+        faraday_response.should_receive(:success?).and_return(false)
+        subject.should_receive(:raise).with(representation)
+        submit_and_complete.raise_on_error
       end
 
       it "raises after completion when called before completion" do
-        faraday_env[:status] = 500
+        faraday_response.should_receive(:success?).and_return(false)
         subject.raise_on_error
-        expect { submit_and_complete }.to raise_error(ServerError)
+        subject.should_receive(:raise).with(representation)
+        submit_and_complete
       end
       
     end
+
   end
 end

data/spec/leadlight/service_middleware_spec.rb

@@ -17,65 +17,28 @@ module Leadlight
     let(:app)     { ->(env){stub(on_complete: nil)} }
     let(:response) { [200, {}, ''] }
     let(:result_env) {
-      test_stack.get('/').env
+      do_get('/').env
     }
     let(:representation) { result_env[:leadlight_representation] }
+    let(:leadlight_request) { stub(:leadlight_request, represent: stub) }
+
+    def do_get(path)
+      test_stack.get(path) do |request|
+        request.options[:leadlight_request] = leadlight_request
+      end
+    end
 
     before do
       faraday_stubs.get('/') {response}
     end
 
     it 'adds :leadlight_service to env before app' do
-      test_stack.get('/').env[:leadlight_service].should equal(service)
-    end
-
-    it 'extends the representation with Representation' do
-      representation.should be_a(Representation)
-    end
-
-    it 'makes the representation hyperlinkable' do
-      representation.should be_a(Hyperlinkable)
+      do_get('/').env[:leadlight_service].should equal(service)
     end
 
     it 'requests JSON, then YAML, then XML, then HTML' do
       result_env[:request_headers]['Accept'].
         should eq('application/json, text/x-yaml, application/xml, application/xhtml+xml, text/html, text/plain')
     end
-
-    context 'with a no-content response' do
-      let(:response) { [204, {}, ''] }
-      let(:result_env) {
-        test_stack.get('/').env
-      }
-
-      it 'sets :leadlight_representation to a Blank' do
-        result_env[:leadlight_representation].should be_a(Blank)
-      end
-    end
-
-    context 'with a blank JSON response' do
-      let(:response) {
-        [200, {'Content-Type' => 'application/json', 'Content-Length' => '0'}, '']
-      }
-      let(:result_env) {
-        test_stack.get('/').env
-      }
-
-      it 'sets :leadlight_representation to a Blank' do
-        result_env[:leadlight_representation].should be_a(Blank)
-      end
-    end
-
-    context 'with a non-blank JSON response' do
-      let(:response) {
-        [200, {'Content-Type' => 'application/json', 'Content-Length' => '7'}, '[1,2,3]']
-      }
-      let(:result_env) {
-        test_stack.get('/').env
-      }
-      it 'sets :leadlight_representation to the result of parsing the JSON' do
-        result_env[:leadlight_representation].should eq([1,2,3])
-      end
-    end
   end
 end

data/spec/leadlight/service_spec.rb

@@ -4,7 +4,14 @@ require 'leadlight/service'
 module Leadlight
   describe Service do
     subject              { klass.new(service_options)                 }
-    let(:klass)          { Class.new do include Service end           }
+    let(:klass)          { 
+      Class.new do 
+        include Service
+        
+        def execute_hook(*)
+        end
+      end          
+    }
     let(:connection)     { stub(:connection, get: response)           }
     let(:representation) { stub(:representation)                      }
     let(:response)       { stub(:response, env: env)                  }
@@ -12,66 +19,65 @@ module Leadlight
     let(:service_options)        { {codec: codec}                     }
     let(:codec)          { stub(:codec)                               }
     let(:request)        { stub(:request).as_null_object              }
+    let(:request_class)  { stub(:request_class, new: request)         }
 
     before do
-      subject.stub(connection: connection, url: nil)
+      subject.stub(connection: connection, 
+                   url: nil,
+                   request_class: request_class)
     end
 
     shared_examples_for "an HTTP client" do |http_method|
       describe "##{http_method}" do
-        before do
-          Request.stub(:new).and_return(request)
-        end
-
         it 'returns a new request object' do
-          Request.should_receive(:new).and_return(request)
+          request_class.should_receive(:new).and_return(request)
           subject.public_send(http_method, '/').should equal(request)
         end
 
+        it 'passes self to the request' do
+          request_class.should_receive(:new).
+            with(subject, anything, anything, anything, anything, anything).
+            and_return(request)
+          subject.public_send(http_method, '/somepath')
+        end
+
         it 'passes the connection to the request' do
-          Request.should_receive(:new).
-            with(connection, anything, anything, anything, anything).
+          request_class.should_receive(:new).
+            with(anything, connection, anything, anything, anything, anything).
             and_return(request)
           subject.public_send(http_method, '/somepath')
         end
 
         it 'passes the path to the request' do
-          Request.should_receive(:new).
-            with(anything, '/somepath', anything, anything, anything).
+          request_class.should_receive(:new).
+            with(anything, anything, '/somepath', anything, anything, anything).
             and_return(request)
           subject.public_send(http_method, '/somepath')
         end
 
         it 'passes the method to the request' do
-          Request.should_receive(:new).
-            with(anything, anything, http_method, anything, anything).
+          request_class.should_receive(:new).
+            with(anything, anything, anything, http_method, anything, anything).
             and_return(request)
           subject.public_send(http_method, '/somepath')
         end
 
         it 'passes the params to the request' do
           params = stub
-          Request.should_receive(:new).
-            with(anything, anything, anything, params, anything).
+          request_class.should_receive(:new).
+            with(anything, anything, anything, anything, params, anything).
             and_return(request)
           subject.public_send(http_method, '/somepath', params)
         end
 
         it 'passes the body to the request' do
           body = stub
-          Request.should_receive(:new).
-            with(anything, anything, anything, anything, body).
+          request_class.should_receive(:new).
+            with(anything, anything, anything, anything, anything, body).
             and_return(request)
           subject.public_send(http_method, '/somepath', {}, body)
         end
 
-        it 'adds a prepare_request callback' do
-          faraday_request = stub(:faraday_request)
-          request.stub(:on_prepare_request).and_yield(faraday_request)
-          subject.should_receive(:prepare_request).with(faraday_request)
-          subject.public_send(http_method, '/')
-        end
-
         context 'given a block' do
           define_method(:do_it) do
             subject.public_send(http_method, '/') do |yielded|

data/spec/leadlight/tint_helper_spec.rb

@@ -10,7 +10,8 @@ module Leadlight
     }
     let(:response) {
       stub(:response,
-           env:          env)
+           env:          env,
+           status:       200)
     }
     let(:env) { {response_headers: headers} }
     let(:headers) {
@@ -75,7 +76,44 @@ module Leadlight
       end
     end
 
+    describe '#match_status' do
+      it 'allows execution to proceed on match' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_status(200)
+          baz
+        end
+      end
+
+      it 'can match on a range' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_status(200..299)
+          baz
+        end
+      end
+
+      it 'does not allow execution to proceed on no match' do
+        object.should_not_receive(:baz)
+        subject.exec_tint do
+          match_status(301)
+          baz
+        end
+      end
+    end
+
     describe '#match' do
+      let(:successful_matcher) {
+        stub.tap do |matcher|
+          matcher.should_receive(:===).with(object).and_return(true)
+        end
+      }
+      let(:failing_matcher) {
+        stub.tap do |matcher|
+          matcher.should_receive(:===).with(object).and_return(false)
+        end
+      }
+
       it 'allows execution to proceed on true return' do
         object.should_receive(:baz)
         subject.exec_tint do
@@ -84,6 +122,34 @@ module Leadlight
         end
       end
 
+      it 'can match a given param against the representation' do
+        matcher = successful_matcher
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match matcher
+          baz
+        end
+      end
+
+      it 'can match several params against the representation' do
+        matchers = [ failing_matcher, successful_matcher ]
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match *matchers
+          baz
+        end
+      end
+
+      it 'can match using params and a block' do
+        param_matcher = failing_matcher
+        block_matcher = proc { (2 + 2) == 4 }
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match param_matcher, &block_matcher
+          baz
+        end
+      end
+
       it 'does not allow execution to proceed on false return' do
         object.should_not_receive(:baz)
         subject.exec_tint do