webmachine 1.2.2 → 1.3.0

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

data/spec/webmachine/request_spec.rb

@@ -11,47 +11,47 @@ describe Webmachine::Request do
 
   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/")
+    expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/"))
   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 +67,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 +101,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 +117,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 +133,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 +149,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 +165,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 +181,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 +197,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 +213,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,13 +229,13 @@ 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