webmachine 1.2.2 → 1.6.0

data/spec/webmachine/decision/fsm_spec.rb

@@ -5,64 +5,126 @@ describe Webmachine::Decision::FSM do
 
   subject { described_class.new(resource, request, response) }
 
+  let(:run_with_exception) do
+    begin
+      subject.run
+    rescue Exception
+    end
+  end
+
   describe 'handling of exceptions from decision methods' do
-    let(:exception) { Exception.new }
+    let(:UNRESCUABLE_exceptions) do
+      Webmachine::RescuableException::UNRESCUABLE
+    end
+
+    describe "rescueable exceptions" do
+      it 'does rescue Exception' do
+        allow(subject).to receive(Webmachine::Decision::Flow::START) { raise(Exception) }
+        expect(resource).to receive(:handle_exception).with instance_of(Exception)
+        expect { subject.run }.to_not raise_error
+      end
+
+      it 'does rescue a failed require' do
+        allow(subject).to receive(Webmachine::Decision::Flow::START) { require 'laterequire' }
+        expect(resource).to receive(:handle_exception).with instance_of(LoadError)
+        expect { subject.run }.to_not raise_error
+      end
+    end
+
+    describe "UNRESCUABLE exceptions"  do
+      shared_examples "UNRESCUABLE" do |e|
+        specify "#{e} is not rescued" do
+          allow(subject).to receive(Webmachine::Decision::Flow::START) {raise(e)}
+          expect(resource).to_not receive(:handle_exception).with instance_of(e)
+          expect { subject.run }.to raise_error(e)
+        end
+      end
+      eary = Webmachine::RescuableException::UNRESCUABLE_DEFAULTS - [
+        Webmachine::MalformedRequest, # Webmachine rescues by default, so it won't re-raise.
+        SignalException # Requires raise in form 'raise SignalException, "SIGSOMESIGNAL"'.
+                        # Haven't found a good no-op signal to use here.
+      ]
+      eary.each{|e| include_examples "UNRESCUABLE", e}
+    end
+  end
+
+  describe 'handling of errors from decision methods' do
+    let(:error) { RuntimeError.new }
 
     before do
-      subject.stub(Webmachine::Decision::Flow::START) { raise exception }
+      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise error }
     end
 
     it 'calls resource.handle_exception' do
-      resource.should_receive(:handle_exception).with(exception)
+      expect(resource).to receive(:handle_exception).with(error)
       subject.run
     end
 
     it 'calls resource.finish_request' do
-      resource.should_receive(:finish_request)
+      expect(resource).to receive(:finish_request)
       subject.run
     end
   end
 
-  describe 'handling of exceptions from resource.handle_exception' do
-    let(:exception) { Exception.new('an error message') }
+  describe 'handling of errors from resource.handle_exception' do
+    let(:error) { RuntimeError.new('an error message') }
 
     before do
-      subject.stub(Webmachine::Decision::Flow::START) { raise }
-      resource.stub(:handle_exception) { raise exception }
+      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise }
+      allow(resource).to receive(:handle_exception) { raise error }
     end
 
     it 'does not call resource.handle_exception again' do
-      resource.should_receive(:handle_exception).once { raise }
+      expect(resource).to receive(:handle_exception).once { raise }
       subject.run
     end
 
     it 'does not call resource.finish_request' do
-      resource.should_not_receive(:finish_request)
+      expect(resource).not_to receive(:finish_request)
       subject.run
     end
 
     it 'renders an error' do
-      Webmachine.
-        should_receive(:render_error).
-        with(500, request, response, { :message => exception.message })
+      expect(Webmachine).
+        to receive(:render_error).
+        with(500, request, response, { :message => error.message })
       subject.run
     end
   end
 
   describe 'handling of exceptions from resource.finish_request' do
-    let(:exception) { Exception.new }
+    let(:exception) { Class.new(Exception).new }
+
+    before do
+      Webmachine::RescuableException.remove(exception)
+      allow(resource).to receive(:finish_request) { raise exception }
+    end
+
+    it 'does not call resource.handle_exception' do
+      expect(resource).to_not receive(:handle_exception)
+      run_with_exception
+    end
+
+    it 'does not call resource.finish_request again' do
+      expect(resource).to receive(:finish_request).once
+      run_with_exception
+    end
+  end
+
+  describe 'handling of errors from resource.finish_request' do
+    let(:error) { RuntimeError.new }
 
     before do
-      resource.stub(:finish_request) { raise exception }
+      allow(resource).to receive(:finish_request) { raise error }
     end
 
     it 'calls resource.handle_exception' do
-      resource.should_receive(:handle_exception).with(exception)
+      expect(resource).to receive(:handle_exception).with(error)
       subject.run
     end
 
     it 'does not call resource.finish_request again' do
-      resource.should_receive(:finish_request).once { raise }
+      expect(resource).to receive(:finish_request).once { raise }
       subject.run
     end
   end
@@ -84,7 +146,7 @@ describe Webmachine::Decision::FSM do
 
     subject.run
 
-    resource_class.current_response_code.should be(201)
+    expect(resource_class.current_response_code).to be(201)
   end
 
   it 'respects a response code set by resource.finish_request' do
@@ -96,6 +158,6 @@ describe Webmachine::Decision::FSM do
 
     subject.run
 
-    response.code.should be(451)
+    expect(response.code).to be(451)
   end
 end

data/spec/webmachine/decision/helpers_spec.rb

@@ -29,20 +29,20 @@ describe Webmachine::Decision::Helpers do
     end
 
     it "should return 415 when no types are accepted" do
-      subject.accept_helper.should == 415
+      expect(subject.accept_helper).to eq 415
     end
 
     it "should return 415 when the posted type is not acceptable" do
       resource.accepted = %W{application/json}
       headers['Content-Type'] = "text/xml"
-      subject.accept_helper.should == 415
+      expect(subject.accept_helper).to eq 415
     end
 
     it "should call the method for the first acceptable type, taking into account params" do
       resource.accepted = ["application/json;v=3", ["application/json", :other]]
-      resource.should_receive(:other).and_return(true)
+      expect(resource).to receive(:other).and_return(true)
       headers['Content-Type'] = 'application/json;v=2'
-      subject.accept_helper.should be_true
+      expect(subject.accept_helper).to be(true)
     end
   end
 
@@ -52,7 +52,7 @@ describe Webmachine::Decision::Helpers do
         response.headers['Content-Length'] = '0'
         response.body = nil
         subject.send :respond, code
-        response.headers.should_not include 'Content-Length'
+        expect(response.headers).to_not include 'Content-Length'
       end
     end
 
@@ -65,7 +65,7 @@ describe Webmachine::Decision::Helpers do
         response.code = code
         response.body = nil
         subject.send :respond, code
-        response.headers['Content-Length'].should == '0'
+        expect(response.headers['Content-Length']).to eq '0'
       end
     end
 
@@ -76,7 +76,7 @@ describe Webmachine::Decision::Helpers do
         response.headers['Transfer-Encoding'] = 'chunked'
         response.body = []
         subject.send :respond, code
-        response.headers.should_not include 'Content-Length'
+        expect(response.headers).to_not include 'Content-Length'
       end
     end
   end
@@ -89,24 +89,24 @@ describe Webmachine::Decision::Helpers do
 
       it "does not modify the response body" do
         subject.encode_body
-        String.should === response.body
+        expect(response.body).to be_instance_of(String)
       end
 
       it "sets the Content-Length header in the response" do
         subject.encode_body
-        response.headers['Content-Length'].should == response.body.bytesize.to_s
+        expect(response.headers['Content-Length']).to eq response.body.bytesize.to_s
       end
     end
 
     shared_examples_for "a non-String body" do
       it "does not set the Content-Length header in the response" do
         subject.encode_body
-        response.headers.should_not have_key('Content-Length')
+        expect(response.headers).to_not have_key('Content-Length')
       end
 
       it "sets the Transfer-Encoding response header to chunked" do
         subject.encode_body
-        response.headers['Transfer-Encoding'].should == 'chunked'
+        expect(response.headers['Transfer-Encoding']).to eq 'chunked'
       end
     end
 
@@ -115,7 +115,7 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in an EnumerableEncoder" do
         subject.encode_body
-        Webmachine::Streaming::EnumerableEncoder.should === response.body
+        expect(response.body).to be_instance_of(Webmachine::Streaming::EnumerableEncoder)
       end
 
       it_should_behave_like "a non-String body"
@@ -126,7 +126,7 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in a CallableEncoder" do
         subject.encode_body
-        Webmachine::Streaming::CallableEncoder.should === response.body
+        expect(response.body).to be_instance_of(Webmachine::Streaming::CallableEncoder)
       end
 
       it_should_behave_like "a non-String body"
@@ -137,7 +137,7 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in a FiberEncoder" do
         subject.encode_body
-        Webmachine::Streaming::FiberEncoder.should === response.body
+        expect(response.body).to be_instance_of(Webmachine::Streaming::FiberEncoder)
       end
 
       it_should_behave_like "a non-String body"
@@ -148,22 +148,22 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in an IOEncoder" do
         subject.encode_body
-        Webmachine::Streaming::IOEncoder.should === response.body
+        expect(response.body).to be_instance_of(Webmachine::Streaming::IOEncoder)
       end
 
       it "sets the Content-Length header to the size of the file" do
         subject.encode_body
-        response.headers['Content-Length'].should == File.stat('spec/spec_helper.rb').size.to_s
+        expect(response.headers['Content-Length']).to eq File.stat('spec/spec_helper.rb').size.to_s
       end
 
       it "progressively yields file contents for each enumeration" do
         subject.encode_body
         body_size = 0
         response.body.each do |chunk|
-          chunk.should be_a(String)
+          expect(chunk).to be_instance_of(String)
           body_size += chunk.length
         end
-        body_size.should == File.stat('spec/spec_helper.rb').size
+        expect(body_size).to eq File.stat('spec/spec_helper.rb').size
       end
 
       context "when the resource provides a non-identity encoding that the client accepts" do
@@ -188,12 +188,12 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in an IOEncoder" do
         subject.encode_body
-        Webmachine::Streaming::IOEncoder.should === response.body
+        expect(response.body).to be_instance_of(Webmachine::Streaming::IOEncoder)
       end
 
       it "sets the Content-Length header to the size of the string" do
         subject.encode_body
-        response.headers['Content-Length'].should == response.body.size.to_s
+        expect(response.headers['Content-Length']).to eq response.body.size.to_s
       end
 
       context "when the resource provides a non-identity encoding that the client accepts" do

data/spec/webmachine/dispatcher/rfc3986_percent_decode_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Webmachine::Dispatcher::Route do
+  describe '#rfc3986_percent_decode' do
+    def call_subject(value)
+      Webmachine::Dispatcher::Route.rfc3986_percent_decode(value)
+    end
+
+    it 'does not change un-encoded strings' do
+      expect(call_subject('this is a normal string, I think')).to eq 'this is a normal string, I think'
+      expect(call_subject('')).to eq ''
+    end
+
+    it 'decodes percent encoded sequences' do
+      expect(call_subject('/tenants/esckimo+test%20%65')).to eq '/tenants/esckimo+test e'
+    end
+
+    it 'leaves incorrectly encoded sequences as is' do
+      expect(call_subject('/tenants/esckimo+test%2%65')).to eq '/tenants/esckimo+test%2e'
+    end
+  end
+end

data/spec/webmachine/dispatcher/route_spec.rb

@@ -1,43 +1,74 @@
 require 'spec_helper'
 
+Webmachine::Dispatcher::Route.class_eval do
+  def warn(*msgs); end # silence warnings for tests
+end
+
 describe Webmachine::Dispatcher::Route do
   let(:method) { "GET" }
   let(:uri) { URI.parse("http://localhost:8080/") }
-  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "") }
+  let(:routing_tokens) { nil }
+  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "", routing_tokens) }
   let(:resource){ Class.new(Webmachine::Resource) }
 
+  describe '#apply' do
+    let(:route) {
+      Webmachine::Dispatcher::Route.new ['hello', :string], resource, {}
+    }
+
+    describe 'a path_info fragment' do
+      let(:uri) { URI.parse("http://localhost:8080/hello/planet%20earth%20++") }
+
+      it 'should decode the value' do
+        route.apply(request)
+        expect(request.path_info).to eq({:string => 'planet earth ++'})
+      end
+    end
+  end
+
   matcher :match_route do |*expected|
     route = Webmachine::Dispatcher::Route.new(expected[0], Class.new(Webmachine::Resource), expected[1] || {})
     match do |actual|
-      request.uri.path = actual if String === actual
-      route.match?(request)
+      uri = URI.parse("http://localhost:8080")
+      uri.path = actual
+      req = Webmachine::Request.new("GET", uri, Webmachine::Headers.new, "", routing_tokens)
+      route.match?(req)
     end
 
-    failure_message_for_should do |_|
+    failure_message do |_|
       "expected route #{expected[0].inspect} to match path #{request.uri.path}"
     end
-    failure_message_for_should_not do |_|
+    failure_message_when_negated do |_|
       "expected route #{expected[0].inspect} not to match path #{request.uri.path}"
     end
   end
 
+  it "warns about the deprecated string splat when initializing" do
+    [["*"],["foo", "*"],["foo", :bar, "*"]].each do |path|
+      route = described_class.allocate
+      expect(route).to receive(:warn)
+      route.send :initialize, path, resource, {}
+    end
+  end
+
   context "matching a request" do
     context "on the root path" do
       subject { "/" }
-      it { should match_route([]) }
-      it { should match_route ['*'] }
-      it { should_not match_route %w{foo} }
-      it { should_not match_route [:id] }
+      it { is_expected.to match_route([]) }
+      it { is_expected.to match_route ['*'] }
+      it { is_expected.to match_route [:*] }
+      it { is_expected.not_to match_route %w{foo} }
+      it { is_expected.not_to match_route [:id] }
     end
 
     context "on a deep path" do
       subject { "/foo/bar/baz" }
-      it { should match_route %w{foo bar baz} }
-      it { should match_route ['foo', :id, "baz"] }
-      it { should match_route %w{foo *} }
-      it { should match_route [:id, '*'] }
-      it { should_not match_route [] }
-      it { should_not match_route %w{bar *} }
+      it { is_expected.to match_route %w{foo bar baz} }
+      it { is_expected.to match_route ['foo', :id, "baz"] }
+      it { is_expected.to match_route ['foo', :*] }
+      it { is_expected.to match_route [:id, :*] }
+      it { is_expected.not_to match_route [] }
+      it { is_expected.not_to match_route ['bar', :*] }
     end
 
     context "with a guard on the request method" do
@@ -53,17 +84,17 @@ describe Webmachine::Dispatcher::Route do
 
       context "when guard passes" do
         let(:method){ "POST" }
-        it { should be_match(request) }
+        it { is_expected.to be_match(request) }
 
         context "but the path match fails" do
           let(:uri){ URI.parse("http://localhost:8080/other") }
-          it { should_not be_match(request) }
+          it { is_expected.not_to be_match(request) }
         end
       end
 
       context "when guard fails" do
         let(:method) { "GET" }
-        it { should_not be_match(request) }
+        it { is_expected.not_to be_match(request) }
       end
 
       context "when the guard responds to #call" do
@@ -85,15 +116,27 @@ describe Webmachine::Dispatcher::Route do
 
         context "when the guard passes" do
           let(:method){ "POST" }
-          it { should be_match(request) }
+          it { is_expected.to be_match(request) }
         end
 
         context "when the guard fails" do
           # let(:method){ "GET" }
-          it { should_not be_match(request) }
+          it { is_expected.not_to be_match(request) }
         end
       end
     end
+
+    context "with a request with explicitly specified routing tokens" do
+      subject { "/some/route/foo/bar" }
+      let(:routing_tokens) { ["foo", "bar"] }
+      it { is_expected.to match_route(["foo", "bar"]) }
+      it { is_expected.to match_route(["foo", :id]) }
+      it { is_expected.to match_route ['*'] }
+      it { is_expected.to match_route [:*] }
+      it { is_expected.not_to match_route(["some", "route", "foo", "bar"]) }
+      it { is_expected.not_to match_route %w{foo} }
+      it { is_expected.not_to match_route [:id] }
+    end
   end
 
   context "applying bindings" do
@@ -102,63 +145,102 @@ describe Webmachine::Dispatcher::Route do
       before { subject.apply(request) }
 
       it "should assign the dispatched path to the empty string" do
-        request.disp_path.should == ""
+        expect(request.disp_path).to eq("")
       end
 
       it "should assign empty bindings" do
-        request.path_info.should == {}
+        expect(request.path_info).to eq({})
       end
 
       it "should assign empty path tokens" do
-        request.path_tokens.should == []
+        expect(request.path_tokens).to eq([])
       end
 
       context "with extra user-defined bindings" do
         subject { described_class.new([], resource, "bar" => "baz") }
 
         it "should assign the user-defined bindings" do
-          request.path_info.should == {"bar" => "baz"}
+          expect(request.path_info).to eq({"bar" => "baz"})
         end
       end
 
       context "with a splat" do
+        subject { described_class.new([:*], resource) }
+
+        it "should assign empty path tokens" do
+          expect(request.path_tokens).to eq([])
+        end
+      end
+
+      context "with a deprecated splat string" do
         subject { described_class.new(['*'], resource) }
 
         it "should assign empty path tokens" do
-          request.path_tokens.should == []
+          expect(request.path_tokens).to eq([])
         end
       end
     end
-
     context "on a deep path" do
       subject { described_class.new(%w{foo bar baz}, resource) }
-      before { request.uri.path = "/foo/bar/baz"; subject.apply(request) }
+      let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz") }
+      before { subject.apply(request) }
 
       it "should assign the dispatched path as the path past the initial slash" do
-        request.disp_path.should == "foo/bar/baz"
+        expect(request.disp_path).to eq("foo/bar/baz")
       end
 
       it "should assign empty bindings" do
-        request.path_info.should == {}
+        expect(request.path_info).to eq({})
       end
 
       it "should assign empty path tokens" do
-        request.path_tokens.should == []
+        expect(request.path_tokens).to eq([])
       end
 
       context "with path variables" do
         subject { described_class.new(['foo', :id, 'baz'], resource) }
 
         it "should assign the path variables in the bindings" do
-          request.path_info.should == {:id => "bar"}
+          expect(request.path_info).to eq({:id => "bar"})
+        end
+      end
+      context "with regex" do
+        subject { described_class.new([/foo/, /(.*)/, 'baz'], resource) }
+
+        it "should assign the captures path variables" do
+          expect(request.path_info).to eq({:captures => ["bar"]})
+        end
+      end
+      context "with multi-capture regex" do
+        subject { described_class.new([/foo/, /(.*)/, /baz\.(.*)/], resource) }
+        let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz.json") }
+
+        it "should assign the captures path variables" do
+          expect(request.path_info).to eq({:captures => ["bar", "json"]})
+        end
+      end
+      context "with named capture regex" do
+        subject { described_class.new(['foo', :bar, /(?<baz>[^.]+)\.(?<format>.*)/], resource) }
+        let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz.json") }
+
+        it "should assign the captures path variables" do
+          expect(request.path_info).to eq({bar: 'bar', baz: 'baz', format: "json"})
         end
       end
 
       context "with a splat" do
+        subject { described_class.new(['foo', :*], resource) }
+
+        it "should capture the path tokens matched by the splat" do
+          expect(request.path_tokens).to eq(%w{ bar baz })
+        end
+      end
+
+      context "with a deprecated splat string" do
         subject { described_class.new(%w{foo *}, resource) }
 
         it "should capture the path tokens matched by the splat" do
-          request.path_tokens.should == %w{ bar baz }
+          expect(request.path_tokens).to eq(%w{ bar baz })
         end
       end
     end