webmachine 1.2.2 → 1.6.0

data/spec/webmachine/request_spec.rb

@@ -3,55 +3,66 @@ require 'spec_helper'
 describe Webmachine::Request do
   subject { request }
 
-  let(:uri)         { URI.parse("http://localhost:8080/some/resource") }
-  let(:http_method) { "GET" }
-  let(:headers)     { Webmachine::Headers.new }
-  let(:body)        { "" }
-  let(:request)     { Webmachine::Request.new(http_method, uri, headers, body) }
+  let(:uri)             { URI.parse("http://localhost:8080/some/resource") }
+  let(:http_method)     { "GET" }
+  let(:headers)         { Webmachine::Headers.new }
+  let(:body)            { "" }
+  let(:routing_tokens)  { nil }
+  let(:base_uri)        { nil }
+  let(:request)         { Webmachine::Request.new(http_method, uri, headers, body, routing_tokens, base_uri) }
 
   it "should provide access to the headers via brackets" do
     subject.headers['Accept'] = "*/*"
-    subject["accept"].should == "*/*"
+    expect(subject["accept"]).to eq("*/*")
   end
 
   it "should provide access to the cookies" do
     subject.headers['Cookie'] = 'name=value;name2=value2';
-    subject.cookies.should == { 'name' => 'value', 'name2' => 'value2' }
+    expect(subject.cookies).to eq({ 'name' => 'value', 'name2' => 'value2' })
   end
 
   it "should handle cookies with extra whitespace" do
     subject.headers['Cookie'] = 'name = value; name2 = value2';
-    subject.cookies.should == { 'name' => 'value', 'name2' => 'value2' }
+    expect(subject.cookies).to eq({ 'name' => 'value', 'name2' => 'value2' })
   end
 
   it "should provide access to the headers via underscored methods" do
     subject.headers["Accept-Encoding"] = "identity"
-    subject.accept_encoding.should == "identity"
-    subject.content_md5.should be_nil
+    expect(subject.accept_encoding).to eq("identity")
+    expect(subject.content_md5).to be_nil
   end
 
-  it "should calculate a base URI" do
-    subject.base_uri.should == URI.parse("http://localhost:8080/")
+  context "base_uri" do
+    it "should calculate a base URI" do
+      expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/"))
+    end
+
+    context "when base_uri has been explicitly set" do
+      let(:base_uri) { URI.parse("http://localhost:8080/some_base_uri/here") }
+      it "should use the provided base_uri" do
+        expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/some_base_uri/here"))
+      end
+    end
   end
 
   it "should provide a hash of query parameters" do
     subject.uri.query = "foo=bar&baz=bam"
-    subject.query.should == {"foo" => "bar", "baz" => "bam"}
+    expect(subject.query).to eq({"foo" => "bar", "baz" => "bam"})
   end
 
   it "should handle = being encoded as a query value." do
     subject.uri.query = "foo=bar%3D%3D"
-    subject.query.should == { "foo" => "bar=="}
+    expect(subject.query).to eq({ "foo" => "bar=="})
   end
 
   it "should treat '+' characters in query parameters as spaces" do
     subject.uri.query = "a%20b=foo+bar&c+d=baz%20quux"
-    subject.query.should == {"a b" => "foo bar", "c d" => "baz quux"}
+    expect(subject.query).to eq({"a b" => "foo bar", "c d" => "baz quux"})
   end
 
   it "should handle a query parameter value of nil" do
     subject.uri.query = nil
-    subject.query.should == {}
+    expect(subject.query).to eq({})
   end
 
   describe '#has_body?' do
@@ -67,31 +78,31 @@ describe Webmachine::Request do
     context "when body is nil" do
       let(:body) { nil }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
 
     context "when body is an empty string" do
       let(:body) { '' }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
 
     context "when body is not empty" do
       let(:body) { 'foo' }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when body is an empty LazyRequestBody" do
       let(:body) { Webmachine::Adapters::LazyRequestBody.new(wreq.new('')) }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
 
     context "when body is a LazyRequestBody" do
       let(:body) { Webmachine::Adapters::LazyRequestBody.new(wreq.new('foo')) }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
   end
 
@@ -101,13 +112,13 @@ describe Webmachine::Request do
     context "when the request was issued via HTTPS" do
       let(:uri) { URI.parse("https://localhost.com:8080/some/resource") }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request was not issued via HTTPS" do
       let(:uri) { URI.parse("http://localhost.com:8080/some/resource") }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -117,13 +128,13 @@ describe Webmachine::Request do
     context "when the request method is GET" do
       let(:http_method) { "GET" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not GET" do
       let(:http_method) { "POST" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -133,13 +144,13 @@ describe Webmachine::Request do
     context "when the request method is HEAD" do
       let(:http_method) { "HEAD" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not HEAD" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -149,13 +160,13 @@ describe Webmachine::Request do
     context "when the request method is POST" do
       let(:http_method) { "POST" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not POST" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -165,13 +176,13 @@ describe Webmachine::Request do
     context "when the request method is PUT" do
       let(:http_method) { "PUT" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not PUT" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -181,13 +192,13 @@ describe Webmachine::Request do
     context "when the request method is DELETE" do
       let(:http_method) { "DELETE" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not DELETE" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -197,13 +208,13 @@ describe Webmachine::Request do
     context "when the request method is TRACE" do
       let(:http_method) { "TRACE" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not TRACE" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -213,13 +224,13 @@ describe Webmachine::Request do
     context "when the request method is CONNECT" do
       let(:http_method) { "CONNECT" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not CONNECT" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -229,14 +240,34 @@ describe Webmachine::Request do
     context "when the request method is OPTIONS" do
       let(:http_method) { "OPTIONS" }
 
-      it { should be_true }
+      it { is_expected.to be(true) }
     end
 
     context "when the request method is not OPTIONS" do
       let(:http_method) { "GET" }
 
-      it { should be_false }
+      it { is_expected.to be(false) }
     end
   end
 
+  describe '#routing_tokens' do
+    subject { request.routing_tokens }
+
+    context "haven't been explicitly set" do
+      let(:routing_tokens) { nil }
+      it "extracts the routing tokens from the path portion of the uri" do
+        expect(subject).to eq(["some", "resource"])
+      end
+    end
+
+    context "have been explicitly set" do
+      let(:routing_tokens) { ["foo", "bar"] }
+
+      it "uses the specified routing_tokens" do
+        expect(subject).to eq(["foo", "bar"])
+      end
+    end
+
+  end
+
 end

data/spec/webmachine/rescueable_exception_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+RSpec.describe Webmachine::RescuableException do
+  before { described_class.default! }
+
+  describe ".UNRESCUABLEs" do
+    specify "returns an array of UNRESCUABLE exceptions" do
+      expect(described_class.UNRESCUABLEs).to eq(described_class::UNRESCUABLE_DEFAULTS)
+    end
+
+    specify "returns an array of UNRESCUABLE exceptions, with custom exceptions added" do
+      described_class.remove(Exception)
+      expect(described_class.UNRESCUABLEs).to eq(described_class::UNRESCUABLE_DEFAULTS.dup.concat([Exception]))
+    end
+  end
+end

data/spec/webmachine/resource/authentication_spec.rb

@@ -31,14 +31,14 @@ describe Webmachine::Resource::Authentication do
     context "when no authorization is sent by the client" do
       it "should reply with a 401 Unauthorized and a WWW-Authenticate header using Basic" do
         subject.run
-        response.code.should == 401
-        response.headers['WWW-Authenticate'].should == 'Basic realm="Webmachine"'
+        expect(response.code).to eq(401)
+        expect(response.headers['WWW-Authenticate']).to eq('Basic realm="Webmachine"')
       end
 
       it "should use the specified realm in the WWW-Authenticate header" do
         resource.realm = "My App"
         subject.run
-        response.headers['WWW-Authenticate'].should == 'Basic realm="My App"'
+        expect(response.headers['WWW-Authenticate']).to eq('Basic realm="My App"')
       end
     end
 
@@ -49,8 +49,8 @@ describe Webmachine::Resource::Authentication do
 
       it "should reply with a 401 Unauthorized and a WWW-Authenticate header using Basic" do
         subject.run
-        response.code.should == 401
-        response.headers['WWW-Authenticate'].should == 'Basic realm="Webmachine"'
+        expect(response.code).to eq(401)
+        expect(response.headers['WWW-Authenticate']).to eq('Basic realm="Webmachine"')
       end
     end
 
@@ -61,7 +61,7 @@ describe Webmachine::Resource::Authentication do
 
       it "should not reply with 401 Unauthorized" do
         subject.run
-        response.code.should_not == 401
+        expect(response.code).not_to eq(401)
       end
     end
   end

data/spec/webmachine/response_spec.rb

@@ -3,20 +3,20 @@ require 'spec_helper'
 describe Webmachine::Response do
 
   it "should have sane default values" do
-    subject.code.should == 200
-    subject.is_redirect?.should be_false
-    subject.headers.should be_empty
+    expect(subject.code).to eq(200)
+    expect(subject.is_redirect?).to be(false)
+    expect(subject.headers).to be_empty
   end
 
   describe "a redirected response" do
     let(:redirect_url) { "/" }
 
-    before(:all) { subject.redirect_to redirect_url }
+    before(:each) { subject.redirect_to redirect_url }
 
-    its(:is_redirect?) { should be_true }
+    its(:is_redirect?) { should be(true) }
 
     it "should have a proper Location header" do
-      subject.headers["Location"].should == redirect_url
+      expect(subject.headers["Location"]).to eq(redirect_url)
     end
   end
 
@@ -24,21 +24,27 @@ describe Webmachine::Response do
     let(:cookie) { "monster" }
     let(:cookie_value) { "mash" }
 
-    before(:all) { subject.set_cookie(cookie, cookie_value) }
+    before(:each) { subject.set_cookie(cookie, cookie_value) }
 
     it "should have a proper Set-Cookie header" do
-      subject.headers["Set-Cookie"].should include "monster=mash";
+      expect(subject.headers["Set-Cookie"]).to include "monster=mash"
     end
 
     describe "setting multiple cookies" do
       let(:cookie2) { "rodeo" }
       let(:cookie2_value) { "clown" }
-      before(:all) { subject.set_cookie(cookie2, cookie2_value) }
+      let(:cookie3) {"color"}
+      let(:cookie3_value) {"blue"}
+      before(:each) do 
+        subject.set_cookie(cookie2, cookie2_value)
+        subject.set_cookie(cookie3, cookie3_value)
+      end
 
       it "should have a proper Set-Cookie header" do
-        subject.headers["Set-Cookie"].should be_a Array
-        subject.headers["Set-Cookie"].should include "rodeo=clown"
-        subject.headers["Set-Cookie"].should include "monster=mash"
+        expect(subject.headers["Set-Cookie"]).to be_a Array
+        expect(subject.headers["Set-Cookie"]).to include "rodeo=clown"
+        expect(subject.headers["Set-Cookie"]).to include "monster=mash"
+        expect(subject.headers["Set-Cookie"]).to include "color=blue"
       end
     end
   end

data/spec/webmachine/trace/fsm_spec.rb

@@ -7,31 +7,31 @@ describe Webmachine::Trace::FSM do
   before { Webmachine::Trace.trace_store = :memory }
 
   context "when tracing is enabled" do
-    before { Webmachine::Trace.stub!(:trace?).and_return(true) }
+    before { allow(Webmachine::Trace).to receive(:trace?).and_return(true) }
 
     it "proxies the resource" do
-      subject.resource.should be_kind_of(Webmachine::Trace::ResourceProxy)
+      expect(subject.resource).to be_kind_of(Webmachine::Trace::ResourceProxy)
     end
 
     it "records a trace" do
       subject.run
-      response.trace.should_not be_empty
-      Webmachine::Trace.traces.should have(1).item
+      expect(response.trace).to_not be_empty
+      expect(Webmachine::Trace.traces.size).to eq(1)
     end
 
     it "commits the trace to separate storage when the request has finished processing" do
-      Webmachine::Trace.should_receive(:record).with(subject.resource.object_id.to_s, response.trace).and_return(true)
+      expect(Webmachine::Trace).to receive(:record).with(subject.resource.object_id.to_s, response.trace).and_return(true)
       subject.run
     end
   end
 
   context "when tracing is disabled" do
-    before { Webmachine::Trace.stub!(:trace?).and_return(false) }
+    before { allow(Webmachine::Trace).to receive(:trace?).and_return(false) }
 
     it "leaves no trace" do
       subject.run
-      response.trace.should be_empty
-      Webmachine::Trace.traces.should be_empty
+      expect(response.trace).to be_empty
+      expect(Webmachine::Trace.traces).to be_empty
     end
   end
 end

data/spec/webmachine/trace/resource_proxy_spec.rb

@@ -7,28 +7,28 @@ describe Webmachine::Trace::ResourceProxy do
 
   it "duck-types all callback methods" do
     Webmachine::Resource::Callbacks.instance_methods(false).each do |m|
-      subject.should respond_to(m)
+      expect(subject).to respond_to(m)
     end
   end
 
   it "logs invocations of callbacks" do
     subject.generate_etag
-    response.trace.should == [{:type => :attempt, :name => "(default)#generate_etag"},
-                              {:type => :result, :value => nil}]
+    expect(response.trace).to eq([{:type => :attempt, :name => "(default)#generate_etag"},
+                              {:type => :result, :value => nil}])
 
   end
 
   it "logs invocations of body-producing methods" do
-    subject.content_types_provided.should == [["text/html", :to_html]]
+    expect(subject.content_types_provided).to eq([["text/html", :to_html]])
     subject.to_html
-    response.trace[-2][:type].should == :attempt
-    response.trace[-2][:name].should =~ /to_html$/
-    response.trace[-2][:source].should include("spec_helper.rb") if response.trace[-2][:source]
-    response.trace[-1].should == {:type => :result, :value => "<html><body>Hello, world!</body></html>"}
+    expect(response.trace[-2][:type]).to eq(:attempt)
+    expect(response.trace[-2][:name]).to match(/to_html$/)
+    expect(response.trace[-2][:source]).to include("spec_helper.rb") if response.trace[-2][:source]
+    expect(response.trace[-1]).to eq({:type => :result, :value => "<html><body>Hello, world!</body></html>"})
   end
 
   it "sets the trace id header when the request has finished processing" do
     subject.finish_request
-    response.headers["X-Webmachine-Trace-Id"].should == subject.object_id.to_s
+    expect(response.headers["X-Webmachine-Trace-Id"]).to eq(subject.object_id.to_s)
   end
 end