webmachine 1.1.0 → 1.2.0

data/spec/support/test_resource.rb

@@ -0,0 +1,73 @@
+module Test
+  class Resource < Webmachine::Resource
+    def allowed_methods
+      ["GET", "PUT", "POST"]
+    end
+
+    def content_types_accepted
+      [
+        ["test/request.stringbody", :from_string],
+        ["test/request.enumbody", :from_enum]
+      ]
+    end
+
+    def content_types_provided
+      [
+        ["test/response.stringbody", :to_string],
+        ["test/response.enumbody", :to_enum],
+        ["test/response.procbody", :to_proc],
+        ["test/response.fiberbody", :to_fiber],
+        ["test/response.iobody", :to_io],
+        ["test/response.cookies", :to_cookies]
+      ]
+    end
+
+    def from_string
+      response.body = "String: #{request.body.to_s}"
+    end
+
+    def from_enum
+      response.body = "Enum: "
+      request.body.each do |part|
+        response.body += part
+      end
+    end
+
+    # Response intentionally left blank to test 204 support
+    def process_post
+      true
+    end
+
+    def to_string
+      "String response body"
+    end
+
+    def to_enum
+      ["Enumerable ", "response " "body"]
+    end
+
+    def to_proc
+      Proc.new { "Proc response body" }
+    end
+
+    def to_fiber
+      Fiber.new do
+        Fiber.yield "Fiber "
+        Fiber.yield "response "
+        "body"
+      end
+    end
+
+    def to_io
+      StringIO.new("IO response body")
+    end
+
+    def to_cookies
+      response.set_cookie("cookie", "monster")
+      response.set_cookie("rodeo", "clown")
+      # FIXME: Mongrel/WEBrick fail if this method returns nil
+      # Might be a net/http issue. Is this a bug?
+      request.cookies["echo"] || ""
+    end
+  end
+end

data/spec/webmachine/adapters/hatetepe_spec.rb

@@ -11,7 +11,7 @@ examples = proc do
 
   describe "#run" do
     it "starts a server" do
-      Hatetepe::Server.should_receive(:start).with(adapter.options) { EM.stop }
+      Hatetepe::Server.should_receive(:start).with(adapter.options) { adapter.shutdown }
       adapter.run
     end
   end
@@ -55,7 +55,7 @@ examples = proc do
   end
 
   def enum_to_s(enum)
-    Enumerator.new(enum).to_a.join
+    enum.to_enum.to_a.join
   end
 end
 

data/spec/webmachine/adapters/mongrel_spec.rb

@@ -1,59 +1,14 @@
 require "spec_helper"
+require "support/adapter_lint"
 
 begin
   describe Webmachine::Adapters::Mongrel do
-    let(:configuration) { Webmachine::Configuration.default }
-    let(:dispatcher) { Webmachine::Dispatcher.new }
-
-    let(:adapter) do
-      described_class.new(configuration, dispatcher)
-    end
-
-    it "inherits from Webmachine::Adapter" do
-      adapter.should be_a_kind_of(Webmachine::Adapter)
-    end
-
-    it "implements #run" do
-      adapter.should respond_to(:run)
-    end
-
-    describe "request handler" do
-      let(:request_params) do
-        {
-          "REQUEST_METHOD" => "GET",
-          "REQUEST_URI" => "http://www.example.com/test?query=string"
-        }
+    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(/Mongrel/)
       end
-      let(:request_body) { StringIO.new("Hello, World!") }
-      let(:mongrel_request) { stub(:params => request_params, :body => request_body) }
-      let(:mongrel_response) { stub.as_null_object }
-
-      subject { Webmachine::Adapters::Mongrel::Handler.new(dispatcher) }
-
-      it "should build a string-like request body" do
-        dispatcher.should_receive(:dispatch) do |request, response|
-          request.body.to_s.should eq("Hello, World!")
-        end
-        subject.process(mongrel_request, mongrel_response)
-      end
-
-      it "should build an enumerable request body" do
-        chunks = []
-        dispatcher.should_receive(:dispatch) do |request, response|
-          request.body.each { |chunk| chunks << chunk }
-        end
-        subject.process(mongrel_request, mongrel_response)
-        chunks.join.should eq("Hello, World!")
-      end
-    end
-
-    it "can run" do
-      # Prevent webserver thread from taking over
-      Thread.stub!(:new).and_return(stub(:join => nil))
-
-      expect {
-        adapter.run
-      }.not_to raise_error
     end
   end
 rescue LoadError

data/spec/webmachine/adapters/rack_spec.rb

@@ -1,169 +1,36 @@
-require 'spec_helper'
+require 'webmachine/adapter'
 require 'webmachine/adapters/rack'
-require 'rack'
-require 'rack/test'
-require 'rack/lint'
-
-module Test
-  class Resource < Webmachine::Resource
-    def allowed_methods
-      ["GET", "PUT", "POST"]
-    end
-
-    def content_types_accepted
-      [["application/json", :from_json]]
-    end
-
-    def content_types_provided
-      [
-        ["text/html", :to_html],
-        ["application/vnd.webmachine.streaming+enum", :to_enum_stream],
-        ["application/vnd.webmachine.streaming+proc", :to_proc_stream]
-      ]
-    end
-
-    def process_post
-      true
-    end
-
-    def to_html
-      response.set_cookie('cookie', 'monster')
-      response.set_cookie('rodeo', 'clown')
-      "<html><body>#{request.cookies['string'] || 'testing'}</body></html>"
-    end
-
-    def to_enum_stream
-      %w{Hello, World!}
-    end
+require 'spec_helper'
+require 'support/adapter_lint'
 
-    def to_proc_stream
-      Proc.new { "Stream" }
+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/)
     end
-
-    def from_json; end
   end
 end
 
-describe Webmachine::Adapters::Rack do
-  include Rack::Test::Methods
-
-  let(:configuration) { Webmachine::Configuration.new('0.0.0.0', 8080, :Rack, {}) }
-  let(:dispatcher)    { Webmachine::Dispatcher.new }
-  let(:adapter) do
-    described_class.new(configuration, dispatcher)
-  end
-  let(:app) { Rack::Lint.new(adapter) }
-
-  before do
-    dispatcher.add_route ['test'], Test::Resource
-  end
-
-  it "inherits from Webmachine::Adapter" do
-    adapter.should be_a_kind_of(Webmachine::Adapter)
-  end
-
-  describe "#run" do
-    before do
-      configuration.adapter_options[:debug] = true
-    end
-
-    it "starts a rack server with the correct options" do
-      Rack::Server.should_receive(:start).with(
-        :app => adapter,
-        :Port => configuration.port,
-        :Host => configuration.ip,
-        :debug => true
-      )
+describe Webmachine::Adapters::Rack::RackResponse do
+  context "on Rack < 1.5 release" do
+    before { Rack.stub(:release => "1.4") }
 
-      adapter.run
+    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")
     end
   end
 
-  it "should proxy request to webmachine" do
-    get "/test"
-    last_response.status.should == 200
-    last_response.original_headers["Content-Type"].should == "text/html"
-    last_response.body.should == "<html><body>testing</body></html>"
-  end
-
-  it "should build a string-like request body" do
-    dispatcher.should_receive(:dispatch) do |request, response|
-      request.body.to_s.should eq("Hello, World!")
-      response.headers["Content-Type"] = "text/plain"
-    end
-    request "/test", :method => "GET", :input => "Hello, World!"
-  end
+  context "on Rack >= 1.5 release" do
+    before { Rack.stub(:release => "1.5") }
 
-  it "should build an enumerable request body" do
-    chunks = []
-    dispatcher.should_receive(:dispatch) do |request, response|
-      request.body.each { |chunk| chunks << chunk }
-      response.headers["Content-Type"] = "text/plain"
+    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")
     end
-    request "/test", :method => "GET", :input => "Hello, World!"
-    chunks.join.should eq("Hello, World!")
-  end
-
-  it "should understand the Content-Type header correctly" do
-    header "CONTENT_TYPE", "application/json"
-    put "/test"
-    last_response.status.should == 204
-  end
-
-  it "should set Server header" do
-    get "/test"
-    last_response.original_headers.should have_key("Server")
-  end
-
-  it "should set Set-Cookie header" do
-    get "/test"
-    # Yes, Rack expects multiple values for a given cookie to be
-    # \n separated.
-    last_response.original_headers["Set-Cookie"].should == "cookie=monster\nrodeo=clown"
-  end
-
-  it "should handle non-success correctly" do
-    get "/missing"
-    last_response.status.should == 404
-    last_response.content_type.should == "text/html"
-  end
-
-  it "should handle empty bodies correctly" do
-    header "CONTENT_TYPE", "application/json"
-    post "/test"
-    last_response.status.should == 204
-    last_response.original_headers.should_not have_key("Content-Type")
-    last_response.original_headers.should_not have_key("Content-Length")
-    last_response.body.should == ""
-  end
-
-  it "should handle cookies correctly" do
-    header "COOKIE", "string=123"
-    get "/test"
-    last_response.status.should == 200
-    last_response.body.should == "<html><body>123</body></html>"
-  end
-
-  it "should handle streaming enumerable response bodies" do
-    header "ACCEPT", "application/vnd.webmachine.streaming+enum"
-    get "/test"
-    last_response.status.should == 200
-    last_response.original_headers["Transfer-Encoding"].should == "chunked"
-    last_response.body.split("\r\n").should == %W{6 Hello, 6 World! 0}
-  end
-
-  it "should handle streaming callable response bodies" do
-    header "ACCEPT", "application/vnd.webmachine.streaming+proc"
-    get "/test"
-    last_response.status.should == 200
-    last_response.original_headers["Transfer-Encoding"].should == "chunked"
-    last_response.body.split("\r\n").should == %W{6 Stream 0}
-  end
-
-  it "should receive Content-Type on Not acceptable response" do
-    header "ACCEPT", "text/plain"
-    get "/test"
-    last_response.status.should == 406
-    last_response.original_headers.should have_key('Content-Type')
   end
 end

data/spec/webmachine/adapters/reel_spec.rb

@@ -1,23 +1,75 @@
 require 'spec_helper'
+require 'support/adapter_lint'
 
 if RUBY_VERSION >= "1.9"
   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)
     end
 
-    it 'inherits from Webmachine::Adapter' do
-      adapter.should be_a_kind_of(Webmachine::Adapter)
-    end
+    context 'websockets' do
+      let(:example_host)    { "www.example.com" }
+      let(:example_path)    { "/example"}
+      let(:example_url)     { "ws://#{example_host}#{example_path}" }
+      let :handshake_headers do
+        {
+          "Host"                   => example_host,
+          "Upgrade"                => "websocket",
+          "Connection"             => "Upgrade",
+          "Sec-WebSocket-Key"      => "dGhlIHNhbXBsZSBub25jZQ==",
+          "Origin"                 => "http://example.com",
+          "Sec-WebSocket-Protocol" => "chat, superchat",
+          "Sec-WebSocket-Version"  => "13"
+        }
+      end
+      let(:client_message) { "Hi server!" }
+      let(:server_message) { "Hi client!" }
+
+      it 'supports websockets' do
+        configuration.adapter_options[:websocket_handler] = proc do |socket|
+          socket.read.should eq client_message
+          socket << server_message
+        end
+
+        reel_server(adapter) do |client|
+          client << WebSocket::ClientHandshake.new(:get, example_url, handshake_headers).to_data
+
+          # Discard handshake response
+          # FIXME: hax
+          client.readpartial(4096)
+
+          client << WebSocket::Message.new(client_message).to_data
+          parser = WebSocket::Parser.new
+          parser.append client.readpartial(4096) until message = parser.next_message
 
-    it 'implements #run' do
-      adapter.should respond_to(:run)
+          message.should eq server_message
+        end
+      end
     end
 
-    it 'implements #process' do
-      adapter.should respond_to(:process)
+    def reel_server(adptr = adapter)
+      thread = Thread.new { adptr.run }
+      begin
+        timeout(5) do
+          begin
+            sock = TCPSocket.new(adptr.configuration.ip, adptr.configuration.port)
+            begin
+              yield(sock)
+            ensure
+              sock.close
+            end
+          rescue Errno::ECONNREFUSED
+            Thread.pass
+            retry
+          end
+        end
+      ensure
+        adptr.shutdown
+      end
     end
   end
 end

data/spec/webmachine/adapters/webrick_spec.rb

@@ -1,18 +1,12 @@
 require "spec_helper"
+require "support/adapter_lint"
 
 describe Webmachine::Adapters::WEBrick do
-  let(:configuration) { Webmachine::Configuration.default }
-  let(:dispatcher) { Webmachine::Dispatcher.new }
-
-  let(:adapter) do
-    described_class.new(configuration, dispatcher)
-  end
-
-  it "inherits from Webmachine::Adapter" do
-    adapter.should be_a_kind_of(Webmachine::Adapter)
-  end
-
-  it "implements #run" do
-    described_class.instance_methods(false).map {|m| m.to_sym }.should include :run
+  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/)
+    end
   end
 end