webmachine 1.2.2 → 1.6.0

data/spec/webmachine/dispatcher_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe Webmachine::Dispatcher do
   let(:dispatcher) { Webmachine.application.dispatcher }
   let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
+  let(:request2) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/hello/bob.html"), Webmachine::Headers["accept" => "*/*"], "") }
   let(:response) { Webmachine::Response.new }
   let(:resource) do
     Class.new(Webmachine::Resource) do
@@ -14,66 +15,90 @@ describe Webmachine::Dispatcher do
       def to_html; "goodbye, cruel world"; end
     end
   end
-  let(:fsm){ mock }
+  let(:resource3) do
+    Class.new(Webmachine::Resource) do
+      def to_html
+        name, format = request.path_info[:captures]
+        "Hello #{name} with #{format}"
+      end
+    end
+  end
+  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 handle regex path segments in route definition" do
+    dispatcher.add_route ["hello", /(.*)\.(.*)/], resource3
+    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource3), request2, response).and_return(fsm)
+    expect(fsm).to receive(:run)
+    dispatcher.dispatch(request2, 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

data/spec/webmachine/errors_spec.rb

@@ -7,7 +7,7 @@ describe "Webmachine errors" do
       res = Webmachine::Response.new
 
       Webmachine.render_error(404, req, res)
-      res.code.should == 404
+      expect(res.code).to eq(404)
     end
   end
 end

data/spec/webmachine/etags_spec.rb

@@ -6,28 +6,28 @@ describe Webmachine::ETag do
 
   subject { etag }
 
-  it { should == etag_str }
-  it { should be_kind_of(described_class) }
+  it { is_expected.to eq(etag_str) }
+  it { is_expected.to be_kind_of(described_class) }
   its(:to_s) { should == '"deadbeef12345678"' }
   its(:etag) { should == '"deadbeef12345678"' }
-  it { should == described_class.new(etag_str.dup) }
+  it { is_expected.to eq(described_class.new(etag_str.dup)) }
 
   context "when the original etag is unquoted" do
     let(:etag_str) { 'deadbeef12345678' }
 
-    it { should == etag_str }
+    it { is_expected.to eq(etag_str) }
     its(:to_s) { should == '"deadbeef12345678"' }
     its(:etag) { should == '"deadbeef12345678"' }
-    it { should == described_class.new(etag_str.dup) }
+    it { is_expected.to eq(described_class.new(etag_str.dup)) }
   end
 
   context "when the original etag contains unbalanced quotes" do
     let(:etag_str) { 'deadbeef"12345678' }
 
-    it { should == etag_str }
+    it { is_expected.to eq(etag_str) }
     its(:to_s) { should == '"deadbeef\\"12345678"' }
     its(:etag) { should == '"deadbeef\\"12345678"' }
-    it { should == described_class.new(etag_str.dup) }
+    it { is_expected.to eq(described_class.new(etag_str.dup)) }
   end
 end
 
@@ -37,39 +37,39 @@ describe Webmachine::WeakETag do
 
   subject { weak_etag }
 
-  it { should == strong_etag }
-  it { should be_kind_of(described_class) }
+  it { is_expected.to eq(strong_etag) }
+  it { is_expected.to be_kind_of(described_class) }
   its(:to_s) { should == 'W/"deadbeef12345678"' }
   its(:etag) { should == '"deadbeef12345678"' }
-  it { should == described_class.new(strong_etag.dup) }
+  it { is_expected.to eq(described_class.new(strong_etag.dup)) }
 
   context "when the original etag is unquoted" do
     let(:strong_etag) { 'deadbeef12345678' }
 
-    it { should == strong_etag }
-    it { should be_kind_of(described_class) }
+    it { is_expected.to eq(strong_etag) }
+    it { is_expected.to be_kind_of(described_class) }
     its(:to_s) { should == 'W/"deadbeef12345678"' }
     its(:etag) { should == '"deadbeef12345678"' }
-    it { should == described_class.new(strong_etag.dup) }
+    it { is_expected.to eq(described_class.new(strong_etag.dup)) }
   end
 
   context "when the original etag contains unbalanced quotes" do
     let(:strong_etag) { 'deadbeef"12345678' }
 
-    it { should == strong_etag }
-    it { should be_kind_of(described_class) }
+    it { is_expected.to eq(strong_etag) }
+    it { is_expected.to be_kind_of(described_class) }
     its(:to_s) { should == 'W/"deadbeef\\"12345678"' }
     its(:etag) { should == '"deadbeef\\"12345678"' }
-    it { should == described_class.new(strong_etag.dup) }
+    it { is_expected.to eq(described_class.new(strong_etag.dup)) }
   end
 
   context "when the original etag is already a weak tag" do
     let(:strong_etag) { 'W/"deadbeef12345678"' }
 
-    it { should == strong_etag }
-    it { should be_kind_of(described_class) }
+    it { is_expected.to eq(strong_etag) }
+    it { is_expected.to be_kind_of(described_class) }
     its(:to_s) { should == 'W/"deadbeef12345678"' }
     its(:etag) { should == '"deadbeef12345678"' }
-    it { should == described_class.new(strong_etag.dup) }
+    it { is_expected.to eq(described_class.new(strong_etag.dup)) }
   end
 end

data/spec/webmachine/events_spec.rb

@@ -3,20 +3,20 @@ require 'spec_helper'
 describe Webmachine::Events do
   describe ".backend" do
     it "defaults to AS::Notifications" do
-      described_class.backend.should be(AS::Notifications)
+      expect(described_class.backend).to be(AS::Notifications)
     end
   end
 
   describe ".publish" do
     it "calls the backend" do
-      described_class.backend.should_receive(:publish).with('test.event', 1, 'two')
+      expect(described_class.backend).to receive(:publish).with('test.event', 1, 'two')
       described_class.publish('test.event', 1, 'two')
     end
   end
 
   describe ".instrument" do
     it "calls the backend" do
-      described_class.backend.should_receive(:instrument).with(
+      expect(described_class.backend).to receive(:instrument).with(
         'test.event', {}
       ).and_yield
 
@@ -26,7 +26,7 @@ describe Webmachine::Events do
 
   describe ".subscribe" do
     it "calls the backend" do
-      described_class.backend.should_receive(:subscribe).with(
+      expect(described_class.backend).to receive(:subscribe).with(
         'test.event'
       ).and_yield
 
@@ -38,7 +38,7 @@ describe Webmachine::Events do
     it "calls the backend" do
       callback = Proc.new { }
 
-      described_class.backend.should_receive(:subscribed).with(
+      expect(described_class.backend).to receive(:subscribed).with(
         callback, 'test.event'
       ).and_yield
 
@@ -50,7 +50,7 @@ describe Webmachine::Events do
     it "calls the backend" do
       subscriber = described_class.subscribe('test.event') { }
 
-      described_class.backend.should_receive(:unsubscribe).with(subscriber)
+      expect(described_class.backend).to receive(:unsubscribe).with(subscriber)
 
       described_class.unsubscribe(subscriber)
     end

data/spec/webmachine/headers_spec.rb

@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Webmachine::Headers do
   it "should set and access values insensitive to case" do
     subject['Content-TYPE'] = "text/plain"
-    subject['CONTENT-TYPE'].should == 'text/plain'
-    subject.delete('CoNtEnT-tYpE').should == 'text/plain'
+    expect(subject['CONTENT-TYPE']).to eq('text/plain')
+    expect(subject.delete('CoNtEnT-tYpE')).to eq('text/plain')
   end
 
   describe "#from_cgi" do
     it "should understand the Content-Length header" do
       headers = described_class.from_cgi("CONTENT_LENGTH" => 14)
-      headers["content-length"].should == 14
+      expect(headers["content-length"]).to eq(14)
     end
   end
 
@@ -22,10 +22,10 @@ describe Webmachine::Headers do
           'Accept', 'application/json'
         ]
 
-        headers.to_hash.should == {
+        expect(headers.to_hash).to eq({
           'content-type' => 'application/json',
           'accept' => 'application/json'
-        }
+        })
       end
     end
 
@@ -38,10 +38,10 @@ describe Webmachine::Headers do
           ]
         ]
 
-        headers.to_hash.should == {
+        expect(headers.to_hash).to eq({
           'content-type' => 'application/json',
           'accept' => 'application/json'
-        }
+        })
       end
     end
 
@@ -52,10 +52,10 @@ describe Webmachine::Headers do
           'Accept' => 'application/json'
         ]
 
-        headers.to_hash.should == {
+        expect(headers.to_hash).to eq({
           'content-type' => 'application/json',
           'accept' => 'application/json'
-        }
+        })
       end
     end
   end
@@ -64,7 +64,7 @@ describe Webmachine::Headers do
     subject { described_class['Content-Type' => 'application/json'] }
 
     it "returns the value for the given key" do
-      subject.fetch('conTent-tYpe').should == 'application/json'
+      expect(subject.fetch('conTent-tYpe')).to eq('application/json')
     end
 
     context "acessing a missing key" do
@@ -74,13 +74,13 @@ describe Webmachine::Headers do
 
       context "and a default value given" do
         it "returns the default value if the key does not exist" do
-          subject.fetch('accept', 'text/html').should == 'text/html'
+          expect(subject.fetch('accept', 'text/html')).to eq('text/html')
         end
       end
 
       context "and a block given" do
         it "passes the value to the block and returns the block's result" do
-          subject.fetch('access') {|k| "#{k} not found"}.should == 'access not found'
+          expect(subject.fetch('access') {|k| "#{k} not found"}).to eq('access not found')
         end
       end
     end
@@ -89,11 +89,11 @@ describe Webmachine::Headers do
   context "filtering with #grep" do
     subject { described_class["content-type" => "text/plain", "etag" => '"abcdef1234567890"'] }
     it "should filter keys by the given pattern" do
-      subject.grep(/content/i).should include("content-type")
+      expect(subject.grep(/content/i)).to include("content-type")
     end
 
     it "should return a Headers instance" do
-      subject.grep(/etag/i).should be_instance_of(described_class)
+      expect(subject.grep(/etag/i)).to be_instance_of(described_class)
     end
   end
 end

data/spec/webmachine/media_type_spec.rb

@@ -5,53 +5,53 @@ describe Webmachine::MediaType do
   subject { described_class.new("application/xml", {"charset" => "UTF-8"}) }
 
   context "equivalence" do
-    it { should == raw_type }
-    it { should == described_class.parse(raw_type) }
+    it { is_expected.to eq(raw_type) }
+    it { is_expected.to eq(described_class.parse(raw_type)) }
   end
 
   context "when it is the wildcard type" do
     subject { described_class.new("*/*") }
-    it { should be_matches_all }
+    it { is_expected.to be_matches_all }
   end
 
   context "parsing a type" do
     it "should return MediaTypes untouched" do
-      described_class.parse(subject).should equal(subject)
+      expect(described_class.parse(subject)).to equal(subject)
     end
 
     it "should parse a String" do
       type = described_class.parse(raw_type)
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should == {"charset" => "UTF-8"}
+      expect(type).to be_kind_of(described_class)
+      expect(type.type).to eq("application/xml")
+      expect(type.params).to eq({"charset" => "UTF-8"})
     end
 
     it "should parse a type/params pair" do
       type = described_class.parse(["application/xml", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should ==  {"charset" => "UTF-8"}
+      expect(type).to be_kind_of(described_class)
+      expect(type.type).to eq("application/xml")
+      expect(type.params).to eq({"charset" => "UTF-8"})
     end
 
     it "should parse a type/params pair where the type has some params in the string" do
       type = described_class.parse(["application/xml;version=1",  {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should ==  {"charset" => "UTF-8", "version" => "1"}
+      expect(type).to be_kind_of(described_class)
+      expect(type.type).to eq("application/xml")
+      expect(type.params).to eq({"charset" => "UTF-8", "version" => "1"})
     end
 
     it "should parse a type/params pair with params and whitespace in the string" do
       type = described_class.parse(["multipart/form-data; boundary=----------------------------2c46a7bec2b9", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "multipart/form-data"
-      type.params.should ==  {"boundary" => "----------------------------2c46a7bec2b9", "charset" => "UTF-8"}
+      expect(type).to be_kind_of(described_class)
+      expect(type.type).to eq("multipart/form-data")
+      expect(type.params).to eq({"boundary" => "----------------------------2c46a7bec2b9", "charset" => "UTF-8"})
     end
 
     it "should parse a type/params pair where type has single-token params" do
       type = described_class.parse(["text/html;q=1;rdfa", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "text/html"
-      type.params.should == {"q" => "1", "rdfa" => "", "charset" => "UTF-8"}
+      expect(type).to be_kind_of(described_class)
+      expect(type.type).to eq("text/html")
+      expect(type.params).to eq({"q" => "1", "rdfa" => "", "charset" => "UTF-8"})
     end
 
     it "should raise an error when given an invalid type/params pair" do
@@ -62,24 +62,24 @@ describe Webmachine::MediaType do
   end
 
   describe "matching a requested type" do
-    it { should     be_exact_match("application/xml;charset=UTF-8") }
-    it { should     be_exact_match("application/*;charset=UTF-8") }
-    it { should     be_exact_match("*/*;charset=UTF-8") }
-    it { should     be_exact_match("*;charset=UTF-8") }
-    it { should_not be_exact_match("text/xml") }
-    it { should_not be_exact_match("application/xml") }
-    it { should_not be_exact_match("application/xml;version=1") }
+    it { is_expected.to     be_exact_match("application/xml;charset=UTF-8") }
+    it { is_expected.to     be_exact_match("application/*;charset=UTF-8") }
+    it { is_expected.to     be_exact_match("*/*;charset=UTF-8") }
+    it { is_expected.to     be_exact_match("*;charset=UTF-8") }
+    it { is_expected.not_to be_exact_match("text/xml") }
+    it { is_expected.not_to be_exact_match("application/xml") }
+    it { is_expected.not_to be_exact_match("application/xml;version=1") }
 
-    it { should     be_type_matches("application/xml") }
-    it { should     be_type_matches("application/*") }
-    it { should     be_type_matches("*/*") }
-    it { should     be_type_matches("*") }
-    it { should_not be_type_matches("text/xml") }
-    it { should_not be_type_matches("text/*") }
+    it { is_expected.to     be_type_matches("application/xml") }
+    it { is_expected.to     be_type_matches("application/*") }
+    it { is_expected.to     be_type_matches("*/*") }
+    it { is_expected.to     be_type_matches("*") }
+    it { is_expected.not_to be_type_matches("text/xml") }
+    it { is_expected.not_to be_type_matches("text/*") }
 
-    it { should     be_params_match({}) }
-    it { should     be_params_match({"charset" => "UTF-8"}) }
-    it { should_not be_params_match({"charset" => "Windows-1252"}) }
-    it { should_not be_params_match({"version" => "3"}) }
+    it { is_expected.to     be_params_match({}) }
+    it { is_expected.to     be_params_match({"charset" => "UTF-8"}) }
+    it { is_expected.not_to be_params_match({"charset" => "Windows-1252"}) }
+    it { is_expected.not_to be_params_match({"version" => "3"}) }
   end
 end