em-websocket 0.2.1 → 0.3.0

data/spec/integration/common_spec.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+# These tests are not specifi to any particular draft of the specification
+# 
+describe "WebSocket server" do
+  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 { EM.stop }
+        http.callback { failed }
+      end
+
+      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
+    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

data/spec/integration/draft03_spec.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'integration/shared_examples'
 
 describe "draft03" do
   before :each do
@@ -31,6 +32,20 @@ describe "draft03" do
     }
   end
 
+  it_behaves_like "a websocket server" do
+    def start_server
+      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        yield ws
+      }
+    end
+
+    def start_client
+      client = EM.connect('0.0.0.0', 12345, Draft03FakeWebSocketClient)
+      client.send_data(format_request(@request))
+      yield client if block_given?
+    end
+  end
+
   # These examples are straight from the spec
   # http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-03#section-4.6
   describe "examples from the spec" do
@@ -48,7 +63,7 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # Send frame
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\x04\x05Hello")
         }
       end
@@ -68,7 +83,7 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # Send frame
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\x84\x03Hel")
           connection.send_data("\x00\x02lo")
         }
@@ -84,11 +99,11 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # Send frame
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\x02\x05Hello")
         }
         
-        connection.onmessage = lambda { |frame|
+        connection.onmessage { |frame|
           next if frame.nil?
           frame.should == "\x03\x05Hello"
           EM.stop
@@ -112,7 +127,7 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # Send frame
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\x05\x7E\x01\x00" + data)
         }
       end
@@ -134,7 +149,7 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # Send frame
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\x05\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data)
         }
       end
@@ -151,12 +166,12 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # Send close frame
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\x01\x00")
         }
 
         # Check that close ack received
-        connection.onmessage = lambda { |frame|
+        connection.onmessage { |frame|
           frame.should == "\x01\x00"
           EM.stop
         }
@@ -181,14 +196,14 @@ describe "draft03" do
         connection.send_data(format_request(@request))
 
         # 3. Check that close frame recieved and acknowlege it
-        connection.onmessage = lambda { |frame|
+        connection.onmessage { |frame|
           frame.should == "\x01\x00"
           ack_received = true
           connection.send_data("\x01\x00")
         }
 
         # 4. Check that connection is closed _after_ the ack
-        connection.onclose = lambda {
+        connection.onclose {
           ack_received.should == true
           EM.stop
         }
@@ -235,7 +250,7 @@ describe "draft03" do
         connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
         connection.send_data(format_request(@request))
 
-        connection.onmessage = lambda { |frame|
+        connection.onmessage { |frame|
           if frame == "\x01\x00"
             # 3. After the close frame is received send a ping frame, but
             # don't respond with a close ack

data/spec/integration/draft05_spec.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+describe "draft05" do
+  before :each do
+    @request = {
+      :port => 80,
+      :method => "GET",
+      :path => "/demo",
+      :headers => {
+        'Host' => 'example.com',
+        'Upgrade' => 'websocket',
+        'Connection' => 'Upgrade',
+        'Sec-WebSocket-Key' => 'dGhlIHNhbXBsZSBub25jZQ==',
+        'Sec-WebSocket-Protocol' => 'sample',
+        'Sec-WebSocket-Origin' => 'http://example.com',
+        'Sec-WebSocket-Version' => '5'
+      }
+    }
+  end
+  
+  def start_server
+    EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+      yield ws
+    }
+  end
+
+  def start_client
+    client = EM.connect('0.0.0.0', 12345, Draft03FakeWebSocketClient)
+    client.send_data(format_request(@request))
+    yield client if block_given?
+  end
+  
+  it "should open connection" do
+    EM.run {
+      start_server { |server|
+        server.onopen {
+          server.instance_variable_get(:@handler).class.should == EventMachine::WebSocket::Handler05
+          EM.stop
+        }
+      }
+      
+      start_client
+    }
+  end
+end

data/spec/integration/draft06_spec.rb

@@ -0,0 +1,79 @@
+require 'helper'
+
+describe "draft06" do
+  before :each do
+    @request = {
+      :port => 80,
+      :method => "GET",
+      :path => "/demo",
+      :headers => {
+        'Host' => 'example.com',
+        'Upgrade' => 'websocket',
+        'Connection' => 'Upgrade',
+        'Sec-WebSocket-Key' => 'dGhlIHNhbXBsZSBub25jZQ==',
+        'Sec-WebSocket-Protocol' => 'sample',
+        'Sec-WebSocket-Origin' => 'http://example.com',
+        'Sec-WebSocket-Version' => '6'
+      }
+    }
+
+    @response = {
+      :protocol => "HTTP/1.1 101 Switching Protocols\r\n",
+      :headers => {
+        "Upgrade" => "websocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Accept" => "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=",
+      }
+    }
+  end
+  
+  def start_server
+    EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+      yield ws
+    }
+  end
+
+  def start_client
+    client = EM.connect('0.0.0.0', 12345, Draft03FakeWebSocketClient)
+    client.send_data(format_request(@request))
+    yield client if block_given?
+  end
+  
+  it "should open connection" do
+    EM.run {
+      start_server { |server|
+        server.onopen {
+          server.instance_variable_get(:@handler).class.should == EventMachine::WebSocket::Handler06
+        }
+      }
+      
+      start_client { |client|
+        client.onopen {
+          client.handshake_response.lines.sort.
+            should == format_response(@response).lines.sort
+          EM.stop
+        }
+      }
+    }
+  end
+  
+  it "should accept a single-frame text message (masked)" do
+    EM.run do
+      start_server { |server|
+        server.onmessage { |msg|
+          msg.should == 'Hello'
+          EM.stop
+        }
+        server.onerror {
+          failed
+        }
+      }
+  
+      start_client { |client|
+        client.onopen {
+          client.send_data("\x00\x00\x01\x00\x84\x05Ielln")
+        }
+      }
+    end
+  end
+end

data/spec/integration/draft75_spec.rb

@@ -0,0 +1,115 @@
+require 'helper'
+require 'integration/shared_examples'
+
+# These integration tests are older and use a different testing style to the 
+# integration tests for newer drafts. They use EM::HttpRequest which happens 
+# to currently estabish a websocket connection using the draft75 protocol.
+# 
+describe "WebSocket server draft75" do
+
+  it_behaves_like "a websocket server" do
+    def start_server
+      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        yield ws
+      }
+    end
+
+    def start_client
+      client = Draft75WebSocketClient.new
+      yield client if block_given?
+    end
+  end
+
+  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 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
+end