webmachine 1.2.2 → 1.3.0

data/spec/webmachine/adapter_spec.rb

@@ -1,39 +1,38 @@
 require "spec_helper"
 
 describe Webmachine::Adapter do
-  let(:configuration) { Webmachine::Configuration.default }
-  let(:dispatcher) { Webmachine::Dispatcher.new }
+  let(:application) { Webmachine::Application.new }
   let(:adapter) do
-    described_class.new(configuration, dispatcher)
+    server = TCPServer.new('0.0.0.0', 0)
+    application.configuration.port = server.addr[1]
+    server.close
+
+    described_class.new(application)
   end
 
   describe "#initialize" do
-    it "stores the provided configuration" do
-      adapter.configuration.should eql configuration
-    end
-
-    it "stores the provided dispatcher" do
-      adapter.dispatcher.should eql dispatcher
+    it "stores the provided application" do
+      expect(adapter.application).to eq(application)
     end
   end
 
   describe ".run" do
     it "creates a new adapter and runs it" do
-      adapter = mock(described_class)
+      adapter = double(described_class)
 
-      described_class.should_receive(:new).
-        with(configuration, dispatcher).
+      expect(described_class).to receive(:new).
+        with(application).
         and_return(adapter)
 
-      adapter.should_receive(:run)
+      expect(adapter).to receive(:run)
 
-      described_class.run(configuration, dispatcher)
+      described_class.run(application)
     end
   end
 
   describe "#run" do
     it "raises a NotImplementedError" do
-      lambda { adapter.run }.should raise_exception(NotImplementedError)
+      expect { adapter.run }.to raise_exception(NotImplementedError)
     end
   end
 

data/spec/webmachine/adapters/httpkit_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+require "webmachine/spec/adapter_lint"
+
+begin
+  describe Webmachine::Adapters::HTTPkit do
+    it_should_behave_like :adapter_lint
+  end
+rescue LoadError
+  warn "Platform is #{RUBY_PLATFORM}: skipping httpkit adapter spec."
+end

data/spec/webmachine/adapters/rack_spec.rb

@@ -7,30 +7,30 @@ describe Webmachine::Adapters::Rack do
   it_should_behave_like :adapter_lint do
     it "should set Server header" do
       response = client.request(Net::HTTP::Get.new("/test"))
-      response["Server"].should match(/Webmachine/)
-      response["Server"].should match(/Rack/)
+      expect(response["Server"]).to match(/Webmachine/)
+      expect(response["Server"]).to match(/Rack/)
     end
   end
 end
 
 describe Webmachine::Adapters::Rack::RackResponse do
   context "on Rack < 1.5 release" do
-    before { Rack.stub(:release => "1.4") }
+    before { allow(Rack).to receive_messages(:release => "1.4") }
 
     it "should add Content-Type header on not acceptable response" do
       rack_response = described_class.new(double(:body), 406, {})
       rack_status, rack_headers, rack_body = rack_response.finish
-      rack_headers.should have_key("Content-Type")
+      expect(rack_headers).to have_key("Content-Type")
     end
   end
 
   context "on Rack >= 1.5 release" do
-    before { Rack.stub(:release => "1.5") }
+    before { allow(Rack).to receive_messages(:release => "1.5") }
 
     it "should not add Content-Type header on not acceptable response" do
       rack_response = described_class.new(double(:body), 406, {})
       rack_status, rack_headers, rack_body = rack_response.finish
-      rack_headers.should_not have_key("Content-Type")
+      expect(rack_headers).not_to have_key("Content-Type")
     end
   end
 end

data/spec/webmachine/adapters/reel_spec.rb

@@ -1,15 +1,19 @@
 require 'spec_helper'
 require 'webmachine/spec/adapter_lint'
 describe Webmachine::Adapters::Reel do
-  it_should_behave_like :adapter_lint
-
-  let(:configuration) { Webmachine::Configuration.default }
-  let(:dispatcher) { Webmachine::Dispatcher.new }
-  let(:adapter) do
-    described_class.new(configuration, dispatcher)
+  context 'lint' do
+    it_should_behave_like :adapter_lint
   end
 
   context 'websockets' do
+    let(:application) { Webmachine::Application.new }
+    let(:adapter) do
+      server = TCPServer.new('0.0.0.0', 0)
+      application.configuration.port = server.addr[1]
+      server.close
+      described_class.new(application)
+    end
+
     let(:example_host)    { "www.example.com" }
     let(:example_path)    { "/example"}
     let(:example_url)     { "ws://#{example_host}#{example_path}" }
@@ -28,8 +32,8 @@ describe Webmachine::Adapters::Reel do
     let(:server_message) { "Hi client!" }
 
     it 'supports websockets' do
-      configuration.adapter_options[:websocket_handler] = proc do |socket|
-        socket.read.should eq client_message
+      application.configuration.adapter_options[:websocket_handler] = proc do |socket|
+        expect(socket.read).to eq client_message
         socket << server_message
       end
 
@@ -44,7 +48,7 @@ describe Webmachine::Adapters::Reel do
         parser = WebSocket::Parser.new
         parser.append client.readpartial(4096) until message = parser.next_message
 
-        message.should eq server_message
+        expect(message).to eq server_message
       end
     end
   end
@@ -54,7 +58,7 @@ describe Webmachine::Adapters::Reel do
     begin
       timeout(5) do
         begin
-          sock = TCPSocket.new(adptr.configuration.ip, adptr.configuration.port)
+          sock = TCPSocket.new(adptr.application.configuration.ip, adptr.application.configuration.port)
           begin
             yield(sock)
           ensure
@@ -66,7 +70,7 @@ describe Webmachine::Adapters::Reel do
         end
       end
     ensure
-      adptr.shutdown
+      thread.kill if thread
     end
   end
 end

data/spec/webmachine/adapters/webrick_spec.rb

@@ -5,8 +5,8 @@ describe Webmachine::Adapters::WEBrick do
   it_should_behave_like :adapter_lint do
     it "should set Server header" do
       response = client.request(Net::HTTP::Get.new("/test"))
-      response["Server"].should match(/Webmachine/)
-      response["Server"].should match(/WEBrick/)
+      expect(response["Server"]).to match(/Webmachine/)
+      expect(response["Server"]).to match(/WEBrick/)
     end
   end
 end

data/spec/webmachine/application_spec.rb

@@ -5,69 +5,70 @@ describe Webmachine::Application do
   let(:test_resource) { Class.new(Webmachine::Resource) }
 
   it "accepts a Configuration when initialized" do
-    config = Webmachine::Configuration.new('1.1.1.1', 9999, :Mongrel, {})
-    described_class.new(config).configuration.should be(config)
+    config = Webmachine::Configuration.new('1.1.1.1', 9999, :Reel, {})
+    expect(described_class.new(config).configuration).to be(config)
   end
 
   it "is yielded into a block provided during initialization" do
     yielded_app = nil
-    described_class.new do |app|
-      app.should be_kind_of(Webmachine::Application)
+    returned_app = described_class.new do |app|
+      expect(app).to be_kind_of(Webmachine::Application)
       yielded_app = app
-    end.should be(yielded_app)
+    end
+    expect(returned_app).to be(yielded_app)
   end
 
   it "is initialized with the default Configration if none is given" do
-    application.configuration.should eq(Webmachine::Configuration.default)
+    expect(application.configuration).to eq(Webmachine::Configuration.default)
   end
 
   it "returns the receiver from the configure call so you can chain it" do
-    application.configure { |c| }.should equal(application)
+    expect(application.configure { |c| }).to equal(application)
   end
 
   it "is configurable" do
     application.configure do |config|
-      config.should be_kind_of(Webmachine::Configuration)
+      expect(config).to be_kind_of(Webmachine::Configuration)
     end
   end
 
   it "is initialized with an empty Dispatcher" do
-    application.dispatcher.routes.should be_empty
+    expect(application.dispatcher.routes).to be_empty
   end
 
   it "can have routes added" do
     route = nil
     resource = test_resource # overcome instance_eval :/
 
-    application.routes.should be_empty
+    expect(application.routes).to be_empty
 
     application.routes do
-      route = add ['*'], resource
+      route = add [:*], resource
     end
 
-    route.should be_kind_of(Webmachine::Dispatcher::Route)
-    application.routes.should eq([route])
+    expect(route).to be_kind_of(Webmachine::Dispatcher::Route)
+    expect(application.routes).to eq([route])
   end
 
   describe "#adapter" do
     let(:adapter_class) { application.adapter_class }
 
     it "returns an instance of it's adapter class" do
-      application.adapter.should be_an_instance_of(adapter_class)
+      expect(application.adapter).to be_an_instance_of(adapter_class)
     end
 
     it "is memoized" do
-      application.adapter.should eql application.adapter
+      expect(application.adapter).to eql application.adapter
     end
   end
 
   it "can be run" do
-    application.adapter.should_receive(:run)
+    expect(application.adapter).to receive(:run)
     application.run
   end
 
   it "can be queried about its configured adapter" do
     expected = Webmachine::Adapters.const_get(application.configuration.adapter)
-    application.adapter_class.should equal(expected)
+    expect(application.adapter_class).to equal(expected)
   end
 end

data/spec/webmachine/chunked_body_spec.rb

@@ -7,7 +7,7 @@ describe Webmachine::ChunkedBody do
     Webmachine::ChunkedBody.new(['foo', 'bar', '', 'j', 'webmachine']).each do |chunk|
       body << chunk
     end
-    body.should == "3\r\nfoo\r\n3\r\nbar\r\n1\r\nj\r\na\r\nwebmachine\r\n0\r\n\r\n"
+    expect(body).to eq("3\r\nfoo\r\n3\r\nbar\r\n1\r\nj\r\na\r\nwebmachine\r\n0\r\n\r\n")
   end
 
   context "with an empty body" do
@@ -16,14 +16,14 @@ describe Webmachine::ChunkedBody do
       Webmachine::ChunkedBody.new([]).each do |chunk|
         body << chunk
       end
-      body.should == "0\r\n\r\n"
+      expect(body).to eq("0\r\n\r\n")
     end
   end
 
   describe "#each" do
     context "without a block given" do
       it "returns an Enumerator" do
-        Webmachine::ChunkedBody.new([]).each.should respond_to(:next)
+        expect(Webmachine::ChunkedBody.new([]).each).to respond_to(:next)
       end
     end
   end

data/spec/webmachine/configuration_spec.rb

@@ -4,13 +4,13 @@ describe Webmachine::Configuration do
   before { Webmachine.configuration = nil }
 
   %w{ip port adapter adapter_options}.each do |field|
-    it { should respond_to(field) }
-    it { should respond_to("#{field}=") }
+    it { is_expected.to respond_to(field) }
+    it { is_expected.to respond_to("#{field}=") }
   end
 
   it "should yield configuration to the block" do
     Webmachine.configure do |config|
-      config.should be_kind_of(described_class)
+      expect(config).to be_kind_of(described_class)
     end
   end
 
@@ -18,10 +18,10 @@ describe Webmachine::Configuration do
     Webmachine.configure do |config|
       @config = config
     end
-    @config.should == Webmachine.configuration
+    expect(@config).to eq Webmachine.configuration
   end
 
   it "should return the module from the configure call so you can chain it" do
-    Webmachine.configure {|c|}.should == Webmachine
+    expect(Webmachine.configure {|c|}).to eq Webmachine
   end
 end

data/spec/webmachine/cookie_spec.rb

@@ -53,14 +53,14 @@ describe Webmachine::Cookie do
 
       it "should include the attributes in its string version" do
         str = subject.to_s
-        str.should include "Secure"
-        str.should include "HttpOnly"
-        str.should include "Comment=comment+with+spaces"
-        str.should include "Domain=www.server.com"
-        str.should include "Path=/"
-        str.should include "Version=1"
-        str.should include "Max-Age=60"
-        str.should include "Expires=Sun, 14-Mar-2010 03:14:00 GMT"
+        expect(str).to include "Secure"
+        expect(str).to include "HttpOnly"
+        expect(str).to include "Comment=comment+with+spaces"
+        expect(str).to include "Domain=www.server.com"
+        expect(str).to include "Path=/"
+        expect(str).to include "Version=1"
+        expect(str).to include "Max-Age=60"
+        expect(str).to include "Expires=Sun, 14-Mar-2010 03:14:00 GMT"
       end
     end
   end
@@ -70,30 +70,30 @@ describe Webmachine::Cookie do
 
     subject { Webmachine::Cookie.parse(str) }
 
-    it("should have the cookie") { subject.should == { "cookie" => "monster" } }
+    it("should have the cookie") { expect(subject).to eq({ "cookie" => "monster" }) }
 
     describe "parsing multiple cookie parameters" do
       let(:str) { "cookie=monster; monster=mash" }
 
-      it("should have both cookies") { subject.should == { "cookie" => "monster", "monster" => "mash" } }
+      it("should have both cookies") { expect(subject).to eq({ "cookie" => "monster", "monster" => "mash" }) }
     end
 
     describe "parsing an encoded cookie" do
       let(:str) { "cookie=yum+yum" }
 
-      it("should decode the cookie") { subject.should == { "cookie" => "yum yum" } }
+      it("should decode the cookie") { expect(subject).to eq({ "cookie" => "yum yum" }) }
     end
 
     describe "parsing nil" do
       let(:str) { nil }
 
-      it("should return empty hash") { subject.should == {} }
+      it("should return empty hash") { expect(subject).to eq({}) }
     end
 
     describe "parsing duplicate cookies" do
       let(:str) { "cookie=monster; cookie=yum+yum" }
 
-      it("should return the first instance of the cookie") { subject.should == { "cookie" => "monster" } }
+      it("should return the first instance of the cookie") { expect(subject).to eq({ "cookie" => "monster" }) }
     end
   end
 end

data/spec/webmachine/decision/conneg_spec.rb

@@ -9,35 +9,35 @@ describe Webmachine::Decision::Conneg do
 
   context "choosing a media type" do
     it "should not choose a type when none are provided" do
-      subject.choose_media_type([], "*/*").should be_nil
+      expect(subject.choose_media_type([], "*/*")).to be_nil
     end
 
     it "should not choose a type when none are acceptable" do
-      subject.choose_media_type(["text/html"], "application/json").should be_nil
+      expect(subject.choose_media_type(["text/html"], "application/json")).to be_nil
     end
 
     it "should choose the first acceptable type" do
-      subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml, text/html, */*").should == "application/xml"
+      expect(subject.choose_media_type(["text/html", "application/xml"],
+                                "application/xml, text/html, */*")).to eq("application/xml")
     end
 
     it "should choose the type that matches closest when matching subparams" do
-      subject.choose_media_type(["text/html",
+      expect(subject.choose_media_type(["text/html",
                                  ["text/html", {"charset" => "iso8859-1"}]],
-                                "text/html;charset=iso8859-1, application/xml").
-        should == "text/html;charset=iso8859-1"
+                                "text/html;charset=iso8859-1, application/xml")).
+        to eq("text/html;charset=iso8859-1")
     end
 
     it "should choose a type more specific than requested when an exact match is not present" do
-      subject.choose_media_type(["application/json;v=3;foo=bar", "application/json;v=2"],
-                                "text/html, application/json").
-        should == "application/json;v=3;foo=bar"
+      expect(subject.choose_media_type(["application/json;v=3;foo=bar", "application/json;v=2"],
+                                "text/html, application/json")).
+        to eq("application/json;v=3;foo=bar")
     end
 
 
     it "should choose the preferred type over less-preferred types" do
-      subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml;q=0.7, text/html, */*").should == "text/html"
+      expect(subject.choose_media_type(["text/html", "application/xml"],
+                                "application/xml;q=0.7, text/html, */*")).to eq("text/html")
 
     end
 
@@ -47,114 +47,120 @@ describe Webmachine::Decision::Conneg do
                                   "bah;")
       }.to raise_error(Webmachine::MalformedRequest)
     end
+
+    it "should choose a type when more than one accept header is present" do
+      expect(subject.choose_media_type(["text/html"],
+                                ["text/html", "text/plain"])).to eq("text/html")
+
+    end
   end
 
   context "choosing an encoding" do
     it "should not set the encoding when none are provided" do
       subject.choose_encoding({}, "identity, gzip")
-      subject.metadata['Content-Encoding'].should be_nil
-      subject.response.headers['Content-Encoding'].should be_nil
+      expect(subject.metadata['Content-Encoding']).to be_nil
+      expect(subject.response.headers['Content-Encoding']).to be_nil
     end
 
     it "should not set the Content-Encoding header when it is identity" do
       subject.choose_encoding({"gzip"=> :encode_gzip, "identity" => :encode_identity}, "identity")
-      subject.metadata['Content-Encoding'].should == 'identity'
-      response.headers['Content-Encoding'].should be_nil
+      expect(subject.metadata['Content-Encoding']).to eq('identity')
+      expect(response.headers['Content-Encoding']).to be_nil
     end
 
     it "should choose the first acceptable encoding" do
       subject.choose_encoding({"gzip" => :encode_gzip}, "identity, gzip")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == 'gzip'
+      expect(subject.metadata['Content-Encoding']).to eq('gzip')
+      expect(response.headers['Content-Encoding']).to eq('gzip')
     end
 
     it "should choose the first acceptable encoding" \
     ", even when no white space after comma" do
       subject.choose_encoding({"gzip" => :encode_gzip}, "identity,gzip")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == 'gzip'
+      expect(subject.metadata['Content-Encoding']).to eq('gzip')
+      expect(response.headers['Content-Encoding']).to eq('gzip')
     end
 
     it "should choose the preferred encoding over less-preferred encodings" do
       subject.choose_encoding({"gzip" => :encode_gzip, "identity" => :encode_identity}, "gzip, identity;q=0.7")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == 'gzip'
+      expect(subject.metadata['Content-Encoding']).to eq('gzip')
+      expect(response.headers['Content-Encoding']).to eq('gzip')
     end
 
     it "should not set the encoding if none are acceptable" do
       subject.choose_encoding({"gzip" => :encode_gzip}, "identity")
-      subject.metadata['Content-Encoding'].should be_nil
-      response.headers['Content-Encoding'].should be_nil
+      expect(subject.metadata['Content-Encoding']).to be_nil
+      expect(response.headers['Content-Encoding']).to be_nil
     end
   end
 
   context "choosing a charset" do
     it "should not set the charset when none are provided" do
       subject.choose_charset([], "ISO-8859-1")
-      subject.metadata['Charset'].should be_nil
+      expect(subject.metadata['Charset']).to be_nil
     end
 
     it "should choose the first acceptable charset" do
       subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII, UTF-8")
-      subject.metadata['Charset'].should == "US-ASCII"
+      expect(subject.metadata['Charset']).to eq("US-ASCII")
     end
 
     it "should choose the preferred charset over less-preferred charsets" do
       subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII;q=0.7, UTF-8")
-      subject.metadata['Charset'].should == "UTF-8"
+      expect(subject.metadata['Charset']).to eq("UTF-8")
     end
 
     it "should not set the charset if none are acceptable" do
       subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "ISO-8859-1")
-      subject.metadata['Charset'].should be_nil
+      expect(subject.metadata['Charset']).to be_nil
     end
 
     it "should choose a charset case-insensitively" do
       subject.choose_charset([["UtF-8", :to_utf8],["US-ASCII", :to_ascii]], "iso-8859-1, utf-8")
-      subject.metadata['Charset'].should == "utf-8"
+      expect(subject.metadata['Charset']).to eq("utf-8")
     end
   end
 
   context "choosing a language" do
     it "should not set the language when none are provided" do
       subject.choose_language([], "en")
-      subject.metadata['Language'].should be_nil
+      expect(subject.metadata['Language']).to be_nil
     end
 
     it "should choose the first acceptable language" do
       subject.choose_language(['en', 'en-US', 'es'], "en-US, es")
-      subject.metadata['Language'].should == "en-US"
-      response.headers['Content-Language'].should == "en-US"
+      expect(subject.metadata['Language']).to eq("en-US")
+      expect(response.headers['Content-Language']).to eq("en-US")
     end
 
     it "should choose the preferred language over less-preferred languages" do
       subject.choose_language(['en', 'en-US', 'es'], "en-US;q=0.6, es")
-      subject.metadata['Language'].should == "es"
-      response.headers['Content-Language'].should == "es"
+      expect(subject.metadata['Language']).to eq("es")
+      expect(response.headers['Content-Language']).to eq("es")
     end
 
     it "should select the first language if all are acceptable" do
       subject.choose_language(['en', 'fr', 'es'], "*")
-      subject.metadata['Language'].should == "en"
-      response.headers['Content-Language'].should == "en"
+      expect(subject.metadata['Language']).to eq("en")
+      expect(response.headers['Content-Language']).to eq("en")
     end
 
     it "should select the closest acceptable language when an exact match is not available" do
       subject.choose_language(['en-US', 'es'], "en, fr")
-      subject.metadata['Language'].should == 'en-US'
-      response.headers['Content-Language'].should == 'en-US'
+      expect(subject.metadata['Language']).to eq('en-US')
+      expect(response.headers['Content-Language']).to eq('en-US')
     end
 
     it "should not set the language if none are acceptable" do
       subject.choose_language(['en'], 'es')
-      subject.metadata['Language'].should be_nil
-      response.headers.should_not include('Content-Language')
+      expect(subject.metadata['Language']).to be_nil
+      expect(response.headers).not_to include('Content-Language')
     end
 
     it "should choose a language case-insensitively" do
       subject.choose_language(['en-US', 'ZH'], 'zh-ch, EN')
-      subject.metadata['Language'].should == 'en-US'
-      response.headers['Content-Language'].should == 'en-US'
+      expect(subject.metadata['Language']).to eq('en-US')
+      expect(response.headers['Content-Language']).to eq('en-US')
     end
   end
 end