leadlight 0.0.2

data/spec/leadlight/request_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper_lite'
+require 'leadlight/request'
+require 'timeout'
+
+module Leadlight
+  describe Request do
+    include Timeout
+
+
+    # The Faraday connection API works like this:
+    #
+    # connection.run_request(:get, ...).on_complete do |env|
+    #   ...
+    # end
+    #
+    # TODO stick a facade over Faraday instead of stubbing stuff I
+    # don't own
+    class FakeFaradayResponse
+      fattr(:completion_handlers) { Queue.new }
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def on_complete(&block)
+        completion_handlers << block
+      end
+
+      def run_completion_handlers(n=1)
+        n.times do
+          completion_handlers.pop.call(@env)
+        end
+      end
+    end
+
+    subject { Request.new(connection, url, http_method, params, body) }
+    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(:on_complete_handlers) { [] }
+    let(:faraday_response) { FakeFaradayResponse.new(faraday_env) }
+    let(:faraday_env)      { {:leadlight_representation => representation} }
+    let(:representation)   { stub(:representation) }
+
+    def run_completion_handlers
+      faraday_response.run_completion_handlers
+    end
+
+    def do_it_and_complete(&block)
+      t = Thread.new do
+        do_it(&block)
+      end
+      run_completion_handlers
+      t.join.value
+    end
+
+    context "for GET" do
+      let(:http_method) { :get }
+
+      its(:http_method) { should eq(:get) }
+    end
+
+
+    context "for POST" do
+      let(:http_method) { :post }
+
+      its(:http_method) { should eq(:post) }
+    end
+
+    describe "#submit" do
+      it "starts a request runnning" do
+        connection.should_receive(:run_request).
+          with(http_method, url, body, {}).
+          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
+        connection.stub(:run_request).
+          and_yield(faraday_request).
+          and_return(faraday_response)
+        subject.on_prepare_request do |request|
+          yielded = request
+        end
+        subject.submit
+        yielded.should equal(faraday_request)
+      end
+
+    end
+
+    shared_examples_for "synchronous methods" do
+      it "returns once the request has completed" do
+        timeout(1) do
+          trace = Queue.new
+          thread = Thread.new do
+            do_it
+            trace << "wait finished"
+          end
+          trace << "completing request"
+          faraday_response.run_completion_handlers
+          thread.join
+          trace << "request completed"
+          trace.pop.should eq("completing request")
+          trace.pop.should eq("wait finished")
+          trace.pop.should eq("request completed")
+        end
+      end
+    end
+
+    describe "#wait" do
+      context "before a submit" do
+        it "doesn't return until after the submit" do
+          timeout(1) do
+            trace = Queue.new
+            thread = Thread.new do
+              subject.wait
+              trace << "wait finished"
+            end
+            trace << "submit"
+            subject.submit
+            trace << "completing request"
+            faraday_response.run_completion_handlers
+            thread.join
+            trace << "request completed"
+            trace.pop.should eq("submit")
+            trace.pop.should eq("completing request")
+            trace.pop.should eq("wait finished")
+            trace.pop.should eq("request completed")
+          end
+        end
+      end
+
+      context "after a submit" do
+        before do
+          subject.submit
+        end
+
+        def do_it
+          subject.wait
+        end
+
+        it_should_behave_like "synchronous methods"
+
+        it "returns self" do
+          do_it_and_complete.should equal(subject)
+        end
+      end
+
+    end
+
+    describe "#submit_and_wait" do
+      def do_it(&block)
+        subject.submit_and_wait(&block)
+      end
+
+      it_should_behave_like "synchronous methods"
+
+      it "returns self" do
+        do_it_and_complete.should equal(subject)
+      end
+
+      it "yields the response representation" do
+        yielded = :nothing
+        do_it_and_complete do |rep|
+          yielded = rep
+        end
+        yielded.should equal(representation)
+      end
+    end
+
+    describe "#on_complete" do
+      def submit_and_complete
+        t = Thread.new do
+          subject.submit
+          subject.wait
+        end
+        run_completion_handlers
+        t.join
+      end
+
+      it "queues hooks to be run on completion" do
+        run_hooks = []
+        subject.on_complete do |response|
+          run_hooks << "hook 1"
+        end
+        subject.on_complete do |response|
+          run_hooks << "hook 2"
+        end
+        submit_and_complete
+        run_hooks.should eq(["hook 1", "hook 2"])
+      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
+        end
+        submit_and_complete
+        yielded.should equal(faraday_response)
+      end
+    end
+
+
+    describe "#raise_on_error" do
+      def submit_and_complete
+        t = Thread.new do
+          subject.submit
+          subject.wait
+        end
+        run_completion_handlers
+        t.join
+        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)
+      end
+
+      it "raises after completion when called before completion" do
+        faraday_env[:status] = 500
+        subject.raise_on_error
+        expect { submit_and_complete }.to raise_error(ServerError)
+      end
+      
+    end
+  end
+end

data/spec/leadlight/service_middleware_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper_lite'
+require 'leadlight/service_middleware'
+require 'faraday'
+
+module Leadlight
+  describe ServiceMiddleware do
+    let(:test_stack) {
+      Faraday.new(url: 'http://example.com') do |b|
+        b.use described_class, service: service
+        b.adapter :test, faraday_stubs
+      end
+    }
+
+    subject { described_class.new(app, service: service) }
+    let(:service) { stub(url: 'http://example.com', tints: []) }
+    let(:faraday_stubs) { Faraday::Adapter::Test::Stubs.new }
+    let(:app)     { ->(env){stub(on_complete: nil)} }
+    let(:response) { [200, {}, ''] }
+    let(:result_env) {
+      test_stack.get('/').env
+    }
+    let(:representation) { result_env[:leadlight_representation] }
+
+    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)
+    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

@@ -0,0 +1,127 @@
+require 'spec_helper_lite'
+require 'leadlight/service'
+
+module Leadlight
+  describe Service do
+    subject              { klass.new(service_options)                 }
+    let(:klass)          { Class.new do include Service end           }
+    let(:connection)     { stub(:connection, get: response)           }
+    let(:representation) { stub(:representation)                      }
+    let(:response)       { stub(:response, env: env)                  }
+    let(:env)            { {leadlight_representation: representation} }
+    let(:service_options)        { {codec: codec}                     }
+    let(:codec)          { stub(:codec)                               }
+    let(:request)        { stub(:request).as_null_object              }
+
+    before do
+      subject.stub(connection: connection, url: nil)
+    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)
+          subject.public_send(http_method, '/').should equal(request)
+        end
+
+        it 'passes the connection to the request' do
+          Request.should_receive(:new).
+            with(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).
+            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).
+            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).
+            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).
+            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|
+              return yielded
+            end
+          end
+
+          it 'submits and waits for completion' do
+            request.should_receive(:submit_and_wait).and_yield(representation)
+            do_it
+          end
+        end
+      end
+    end
+
+    it_behaves_like "an HTTP client", :head
+    it_behaves_like "an HTTP client", :get
+    it_behaves_like "an HTTP client", :post
+    it_behaves_like "an HTTP client", :put
+    it_behaves_like "an HTTP client", :delete
+    it_behaves_like "an HTTP client", :patch
+    it_behaves_like "an HTTP client", :options
+
+    describe '#service_options' do
+      it 'returns option values passed to the initializer' do
+        it = klass.new(foo: 42, bar: 'baz')
+        it.service_options.should eq(foo: 42, bar: 'baz')
+      end
+    end
+
+    describe '#encode' do
+      it 'delegates to the codec' do
+        entity = stub
+        codec.should_receive(:encode).
+          with('CONTENT_TYPE', representation, {foo: 'bar'}).
+          and_return(entity)
+        subject.encode('CONTENT_TYPE', representation, {foo: 'bar'}).
+          should equal(entity)
+      end
+    end
+
+    describe '#decode' do
+      it 'delegates to the codec' do
+        entity = stub
+        codec.should_receive(:decode).
+          with('CONTENT_TYPE', entity, {foo: 'bar'}).
+          and_return(representation)
+        subject.decode('CONTENT_TYPE', entity, {foo: 'bar'}).
+          should equal(representation)
+      end
+    end
+  end
+end

data/spec/leadlight/tint_helper_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper_lite'
+require 'leadlight/tint_helper'
+
+module Leadlight
+  describe TintHelper do
+    subject{ TintHelper.new(object, tint) }
+    let(:object) {
+      stub(__location__: stub(path: '/the/path'),
+           __response__: response)
+    }
+    let(:response) {
+      stub(:response,
+           env:          env)
+    }
+    let(:env) { {response_headers: headers} }
+    let(:headers) {
+      { 'Content-Type' => 'text/html; charset=UTF-8'}
+    }
+    let(:tint) { Module.new }
+
+    it 'forwards unknown calls to the wrapped object' do
+      object.should_receive(:foo).with('bar')
+      subject.foo('bar')
+    end
+
+    describe '#match_path' do
+      it 'allows execution to proceed on match' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_path('/the/path')
+          baz
+        end
+      end
+
+      it 'can match on a Regexp' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_path(/path/)
+          baz
+        end
+      end
+
+      it 'does not allow execution to proceed on no match' do
+        object.should_not_receive(:baz)
+        subject.exec_tint do
+          match_path('/the/wrong/path')
+          baz
+        end
+      end
+    end
+
+    describe '#match_content_type' do
+      it 'allows execution to proceed on match' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_content_type('text/html')
+          baz
+        end
+      end
+
+      it 'can match on a regex' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match_content_type(/text/)
+          baz
+        end
+      end
+
+      it 'does not allow execution to proceed on no match' do
+        object.should_not_receive(:baz)
+        subject.exec_tint do
+          match_content_type('text/plain')
+          baz
+        end
+      end
+    end
+
+    describe '#match' do
+      it 'allows execution to proceed on true return' do
+        object.should_receive(:baz)
+        subject.exec_tint do
+          match{ (2 + 2) == 4 }
+          baz
+        end
+      end
+
+      it 'does not allow execution to proceed on false return' do
+        object.should_not_receive(:baz)
+        subject.exec_tint do
+          match{ (2 + 2) == 5 }
+          baz
+        end
+      end
+    end
+
+    describe '#exec_tint' do
+      it 'returns self' do
+        subject.exec_tint{}.should equal(subject)
+      end
+    end
+
+    describe '#add_header' do
+      it 'adds a header' do
+        subject.add_header('MyHeader', 'Hello world')
+        headers['MyHeader'].should eq('Hello world')
+      end
+    end
+
+    describe '#extend' do
+      context 'given a module' do
+        let(:mod) { Module.new }
+
+        it 'extends the object with the given module' do
+          subject.extend(mod)
+          object.should be_a(mod)
+        end
+      end
+
+      context 'given a block' do
+        it 'extends the tint module with the given definitions' do
+          subject.extend do
+            def magic_word
+              'xyzzy'
+            end
+          end
+          object.magic_word.should eq('xyzzy')
+        end
+      end
+    end
+
+  end
+end