webmachine 1.2.2 → 1.3.0

data/spec/webmachine/decision/fsm_spec.rb

@@ -6,63 +6,63 @@ describe Webmachine::Decision::FSM do
   subject { described_class.new(resource, request, response) }
 
   describe 'handling of exceptions from decision methods' do
-    let(:exception) { Exception.new }
+    let(:exception) { RuntimeError.new }
 
     before do
-      subject.stub(Webmachine::Decision::Flow::START) { raise exception }
+      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise exception }
     end
 
     it 'calls resource.handle_exception' do
-      resource.should_receive(:handle_exception).with(exception)
+      expect(resource).to receive(:handle_exception).with(exception)
       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') }
+    let(:exception) { 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 exception }
     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).
+      expect(Webmachine).
+        to receive(:render_error).
         with(500, request, response, { :message => exception.message })
       subject.run
     end
   end
 
   describe 'handling of exceptions from resource.finish_request' do
-    let(:exception) { Exception.new }
+    let(:exception) { RuntimeError.new }
 
     before do
-      resource.stub(:finish_request) { raise exception }
+      allow(resource).to receive(:finish_request) { raise exception }
     end
 
     it 'calls resource.handle_exception' do
-      resource.should_receive(:handle_exception).with(exception)
+      expect(resource).to receive(:handle_exception).with(exception)
       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 +84,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 +96,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/route_spec.rb

@@ -1,11 +1,32 @@
 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(:resource){ Class.new(Webmachine::Resource) }
 
+  describe '#apply' do
+    let(:route) {
+      Webmachine::Dispatcher::Route.new ['hello', :string], resource, {}
+    }
+
+    describe 'a path_info fragment' do
+      before do
+        uri.path = '/hello/planet%20earth%20++'
+      end
+
+      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|
@@ -13,31 +34,40 @@ describe Webmachine::Dispatcher::Route do
       route.match?(request)
     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 +83,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,12 +115,12 @@ 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
@@ -102,30 +132,38 @@ 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
@@ -135,30 +173,38 @@ describe Webmachine::Dispatcher::Route do
       before { request.uri.path = "/foo/bar/baz"; 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 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

data/spec/webmachine/dispatcher_spec.rb

@@ -14,66 +14,76 @@ describe Webmachine::Dispatcher do
       def to_html; "goodbye, cruel world"; end
     end
   end
-  let(:fsm){ mock }
+  let(:fsm){ double }
 
   before { dispatcher.reset }
 
   it "should add routes from a block" do
     _resource = resource
-    Webmachine.routes do
-      add ['*'], _resource
-    end.should == Webmachine
-    dispatcher.routes.should have(1).item
+    expect(Webmachine.routes do
+      add [:*], _resource
+    end).to eq(Webmachine)
+    expect(dispatcher.routes.size).to eq(1)
   end
 
   it "should add routes" do
     expect {
-      dispatcher.add_route ['*'], resource
+      dispatcher.add_route [:*], resource
     }.to_not raise_error
   end
 
   it "should have add_route return the newly created route" do
-    route = dispatcher.add_route ['*'], resource
-    route.should be_instance_of Webmachine::Dispatcher::Route
+    route = dispatcher.add_route [:*], resource
+    expect(route).to be_instance_of Webmachine::Dispatcher::Route
   end
 
   it "should route to the proper resource" do
     dispatcher.add_route ["goodbye"], resource2
-    dispatcher.add_route ['*'], resource
-    Webmachine::Decision::FSM.should_receive(:new).with(instance_of(resource), request, response).and_return(fsm)
-    fsm.should_receive(:run)
+    dispatcher.add_route [:*], resource
+    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource), request, response).and_return(fsm)
+    expect(fsm).to receive(:run)
     dispatcher.dispatch(request, response)
   end
 
   it "should apply route to request before creating the resource" do
-    route   = dispatcher.add_route ["*"], resource
+    route   = dispatcher.add_route [:*], resource
     applied = false
 
-    route.should_receive(:apply) { applied = true }
-    resource.should_receive(:new) do
-      applied.should be_true
+    expect(route).to receive(:apply) { applied = true }
+    expect(resource).to(receive(:new) do
+      expect(applied).to be(true)
       resource2.new(request, response)
-    end
+    end)
 
     dispatcher.dispatch(request, response)
   end
 
   it "should add routes with guards" do
     dispatcher.add [], lambda {|req| req.method == "POST" }, resource
-    dispatcher.add ['*'], resource2 do |req|
+    dispatcher.add [:*], resource2 do |req|
       !req.query.empty?
     end
     request.uri.query = "?foo=bar"
-    dispatcher.routes.should have(2).items
-    Webmachine::Decision::FSM.should_receive(:new).with(instance_of(resource2), request, response).and_return(fsm)
-    fsm.should_receive(:run)
+    expect(dispatcher.routes.size).to eq(2)
+    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource2), request, response).and_return(fsm)
+    expect(fsm).to receive(:run)
+    dispatcher.dispatch(request, response)
+  end
+
+  it "should respond with a valid resource for a 404" do
     dispatcher.dispatch(request, response)
+    expect(response.code).to     eq(404)
+    expect(response.body).to_not be_empty
+    expect(response.headers).to  have_key('Content-Length')
+    expect(response.headers).to  have_key('Date')
   end
 
-  it "should respond with valid resource missing response for request to non-existing route" do
+  it "should respond with a valid resource for a 404 with a custom Accept header" do
+    request.headers['Accept'] = "application/json"
     dispatcher.dispatch(request, response)
-    response.code.should     eq(404)
-    response.body.should_not be_empty
-    response.headers.should  have_key('Content-Length')
+    expect(response.code).to     eq(404)
+    expect(response.body).to_not be_empty
+    expect(response.headers).to  have_key('Content-Length')
+    expect(response.headers).to  have_key('Date')
   end
 end