websocket-rack 0.1.4 → 0.2.1

data/spec/unit/handler_spec.rb

@@ -1,136 +0,0 @@
-require 'helper'
-
-describe "Rack::WebSocket::Handler" do
-  before :each do
-    @request = {
-      :port => 80,
-      :method => "GET",
-      :path => "/demo",
-      :headers => {
-        'Host' => 'example.com',
-        'Connection' => 'Upgrade',
-        'Sec-WebSocket-Key2' => '12998 5 Y3 1  .P00',
-        'Sec-WebSocket-Protocol' => 'sample',
-        'Upgrade' => 'WebSocket',
-        'Sec-WebSocket-Key1' => '4 @1  46546xW%0l 1 5',
-        'Origin' => 'http://example.com'
-      },
-      :body => '^n:ds[4U'
-    }
-    @secure_request = @request.merge(:port => 443)
-
-    @response = {
-      :headers => {
-        "Upgrade" => "WebSocket",
-        "Connection" => "Upgrade",
-        "Sec-WebSocket-Location" => "ws://example.com/demo",
-        "Sec-WebSocket-Origin" => "http://example.com",
-        "Sec-WebSocket-Protocol" => "sample"
-      },
-      :body => "8jKS\'y:G*Co,Wxa-"
-    }
-    @secure_response = @response.merge(:headers => @response[:headers].merge('Sec-WebSocket-Location' => "wss://example.com:443/demo"))
-  end
-
-  it "should handle good request" do
-    handler(@request).should send_handshake(@response)
-  end
-
-  it "should handle good request to secure default port if secure mode is enabled" do
-    handler(@secure_request, true).should send_handshake(@secure_response)
-  end
-
-  it "should not handle good request to secure default port if secure mode is disabled" do
-    handler(@secure_request, false).should_not send_handshake(@secure_response)
-  end
-
-  it "should handle good request on nondefault port" do
-    @request[:port] = 8081
-    @request[:headers]['Host'] = 'example.com:8081'
-    @response[:headers]['Sec-WebSocket-Location'] =
-      'ws://example.com:8081/demo'
-
-    handler(@request).should send_handshake(@response)
-  end
-
-  it "should handle good request to secure nondefault port" do
-    @secure_request[:port] = 8081
-    @secure_request[:headers]['Host'] = 'example.com:8081'
-    @secure_response[:headers]['Sec-WebSocket-Location'] = 'wss://example.com:8081/demo'
-    handler(@secure_request, true).should send_handshake(@secure_response)
-  end
-
-  it "should handle good request with no protocol" do
-    @request[:headers].delete('Sec-WebSocket-Protocol')
-    @response[:headers].delete("Sec-WebSocket-Protocol")
-
-    handler(@request).should send_handshake(@response)
-  end
-
-  it "should handle extra headers by simply ignoring them" do
-    @request[:headers]['EmptyValue'] = ""
-    @request[:headers]['AKey'] = "AValue"
-
-    handler(@request).should send_handshake(@response)
-  end
-
-  it "should raise error on HTTP request" do
-    @request[:headers] = {
-      'Host' => 'www.google.com',
-      'User-Agent' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 GTB6 GTBA',
-      'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-      'Accept-Language' => 'en-us,en;q=0.5',
-      'Accept-Encoding' => 'gzip,deflate',
-      'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
-      'Keep-Alive' => '300',
-      'Connection' => 'keep-alive',
-    }
-
-    lambda {
-      handler(@request).handshake
-    }.should raise_error(Rack::WebSocket::HandshakeError)
-  end
-
-  it "should raise error on wrong method" do
-    @request[:method] = 'POST'
-
-    lambda {
-      handler(@request).handshake
-    }.should raise_error(Rack::WebSocket::HandshakeError)
-  end
-
-  it "should raise error if upgrade header incorrect" do
-    @request[:headers]['Upgrade'] = 'NonWebSocket'
-
-    lambda {
-      handler(@request).handshake
-    }.should raise_error(Rack::WebSocket::HandshakeError)
-  end
-
-  it "should raise error if Sec-WebSocket-Protocol is empty" do
-    @request[:headers]['Sec-WebSocket-Protocol'] = ''
-
-    lambda {
-      handler(@request).handshake
-    }.should raise_error(Rack::WebSocket::HandshakeError)
-  end
-
-  %w[Sec-WebSocket-Key1 Sec-WebSocket-Key2].each do |header|
-    it "should raise error if #{header} has zero spaces" do
-      @request[:headers][header] = 'nospaces'
-
-      lambda {
-        handler(@request).handshake
-      }.should raise_error(Rack::WebSocket::HandshakeError, 'Websocket Key1 or Key2 does not contain spaces - this is a symptom of a cross-protocol attack')
-    end
-  end
-  
-  it "should raise error if spaces do not divide numbers in Sec-WebSocket-Key* " do
-    @request[:headers]['Sec-WebSocket-Key2'] = '12998 5 Y3 1.P00'
-
-    lambda {
-      handler(@request).handshake
-    }.should raise_error(Rack::WebSocket::HandshakeError, 'Invalid Key "12998 5 Y3 1.P00"')
-  end
-
-end

data/spec/websocket_spec.rb

@@ -1,210 +0,0 @@
-# require 'helper'
-# 
-# describe Rack::WebSocket do
-# 
-#   it "should automatically complete WebSocket handshake" do
-#     EM.run do
-#       MSG = "Hello World!"
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-#         http.errback { failed }
-#         http.callback { http.response_header.status.should == 101 }
-# 
-#         http.stream { |msg|
-#           msg.should == MSG
-#           EventMachine.stop
-#         }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen {
-#           ws.send MSG
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should fail on non WebSocket requests" do
-#     EM.run do
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
-#         http.errback { failed }
-#         http.callback {
-#           http.response_header.status.should == 400
-#           EventMachine.stop
-#         }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
-#     end
-#   end
-# 
-#   it "should split multiple messages into separate callbacks" do
-#     EM.run do
-#       messages = %w[1 2]
-#       received = []
-# 
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-#         http.errback { failed }
-#         http.stream {|msg|}
-#         http.callback {
-#           http.response_header.status.should == 101
-#           http.send messages[0]
-#           http.send messages[1]
-#         }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen {}
-#         ws.onclose {}
-#         ws.onmessage {|msg|
-#           msg.should == messages[received.size]
-#           received.push msg
-# 
-#           EventMachine.stop if received.size == messages.size
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should call onclose callback when client closes connection" do
-#     EM.run do
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-#         http.errback { failed }
-#         http.callback {
-#           http.response_header.status.should == 101
-#           http.close_connection
-#         }
-#         http.stream{|msg|}
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen {}
-#         ws.onclose {
-#           ws.state.should == :closed
-#           EventMachine.stop
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should call onerror callback with raised exception and close connection on bad handshake" do
-#     EM.run do
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
-#         http.errback { http.response_header.status.should == 0 }
-#         http.callback { failed }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen { failed }
-#         ws.onclose { EventMachine.stop }
-#         ws.onerror {|e|
-#           e.should be_an_instance_of EventMachine::WebSocket::HandshakeError
-#           e.message.should match('Connection and Upgrade headers required')
-#           EventMachine.stop
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should populate ws.request with appropriate headers" do
-#     EM.run do
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-#         http.errback { failed }
-#         http.callback {
-#           http.response_header.status.should == 101
-#           http.close_connection
-#         }
-#         http.stream { |msg| }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen {
-#           ws.request["User-Agent"].should == "EventMachine HttpClient"
-#           ws.request["Connection"].should == "Upgrade"
-#           ws.request["Upgrade"].should == "WebSocket"
-#           ws.request["Path"].should == "/"
-#           ws.request["Origin"].should == "127.0.0.1"
-#           ws.request["Host"].to_s.should == "ws://127.0.0.1:12345"
-#         }
-#         ws.onclose {
-#           ws.state.should == :closed
-#           EventMachine.stop
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should allow sending and retrieving query string args passed in on the connection request." do
-#     EM.run do
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:query => {'foo' => 'bar', 'baz' => 'qux'}, :timeout => 0)
-#         http.errback { failed }
-#         http.callback {
-#           http.response_header.status.should == 101
-#           http.close_connection
-#         }
-#         http.stream { |msg| }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen {
-#           path, query = ws.request["Path"].split('?')
-#           path.should == '/'
-#           Hash[*query.split(/&|=/)].should == {"foo"=>"bar", "baz"=>"qux"}
-#           ws.request["Query"]["foo"].should == "bar"
-#           ws.request["Query"]["baz"].should == "qux"
-#         }
-#         ws.onclose {
-#           ws.state.should == :closed
-#           EventMachine.stop
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should ws.response['Query'] to empty hash when no query string params passed in connection URI" do
-#     EM.run do
-#       EventMachine.add_timer(0.1) do
-#         http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
-#         http.errback { failed }
-#         http.callback {
-#           http.response_header.status.should == 101
-#           http.close_connection
-#         }
-#         http.stream { |msg| }
-#       end
-# 
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-#         ws.onopen {
-#           ws.request["Path"].should == "/"
-#           ws.request["Query"].should == {}
-#         }
-#         ws.onclose {
-#           ws.state.should == :closed
-#           EventMachine.stop
-#         }
-#       end
-#     end
-#   end
-# 
-#   it "should raise an exception if frame sent before handshake complete" do
-#     EM.run {
-#       EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |c|
-#         # We're not using a real client so the handshake will not be sent
-#         EM.add_timer(0.1) {
-#           lambda {
-#             c.send('early message')
-#           }.should raise_error('Cannot send data before onopen callback')
-#           EM.stop
-#         }
-#       }
-# 
-#       client = EM.connect('0.0.0.0', 12345, EM::Connection)
-#     }
-#   end
-# end