sonixlabs-em-websocket 0.3.8 → 0.5.1.1

data/spec/integration/common_spec.rb

@@ -1,118 +1,138 @@
 require 'helper'
 
-# These tests are not specifi to any particular draft of the specification
-# 
+# These tests are not specific to any particular draft of the specification
+#
 describe "WebSocket server" do
   include EM::SpecHelper
   default_timeout 1
 
   it "should fail on non WebSocket requests" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
+      EM.add_timer(0.1) do
+        http = EM::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
         http.errback { done }
         http.callback { fail }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
+      start_server
     }
   end
-  
-  it "should populate ws.request with appropriate headers" do
+
+  it "should expose the WebSocket request headers, path and query params" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-        http.errback { fail }
-        http.callback {
-          http.response_header.status.should == 101
-          http.close_connection
-        }
-        http.stream { |msg| }
+      EM.add_timer(0.1) do
+        ws = EventMachine::WebSocketClient.connect('ws://127.0.0.1:12345/',
+                                                   :origin => 'http://example.com')
+        ws.errback { fail }
+        ws.callback { ws.close_connection }
+        ws.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"
+      start_server do |ws|
+        ws.onopen { |handshake|
+          headers = handshake.headers
+          headers["Connection"].should == "Upgrade"
+          headers["Upgrade"].should == "websocket"
+          headers["Host"].to_s.should == "127.0.0.1:12345"
+          handshake.path.should == "/"
+          handshake.query.should == {}
+          handshake.origin.should == 'http://example.com'
         }
         ws.onclose {
           ws.state.should == :closed
-          EventMachine.stop
+          done
         }
       end
     }
   end
-  
-  it "should allow sending and retrieving query string args passed in on the connection request." do
+
+  it "should expose the WebSocket path and query params when nonempty" do
     em {
-      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 { fail }
-        http.callback {
-          http.response_header.status.should == 101
-          http.close_connection
+      EM.add_timer(0.1) do
+        ws = EventMachine::WebSocketClient.connect('ws://127.0.0.1:12345/hello?foo=bar&baz=qux')
+        ws.errback { fail }
+        ws.callback {
+          ws.close_connection
         }
-        http.stream { |msg| }
+        ws.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"
+      start_server do |ws|
+        ws.onopen { |handshake|
+          handshake.path.should == '/hello'
+          handshake.query_string.split('&').sort.
+            should == ["baz=qux", "foo=bar"]
+          handshake.query.should == {"foo"=>"bar", "baz"=>"qux"}
         }
         ws.onclose {
           ws.state.should == :closed
-          EventMachine.stop
+          done
         }
       end
     }
   end
-  
-  it "should ws.response['Query'] to empty hash when no query string params passed in connection URI" do
+
+  it "should raise an exception if frame sent before handshake complete" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
-        http.errback { fail }
-        http.callback {
-          http.response_header.status.should == 101
-          http.close_connection
-        }
-        http.stream { |msg| }
+      # 1. Start WebSocket server
+      start_server { |ws|
+        # 3. Try to send a message to the socket
+        lambda {
+          ws.send('early message')
+        }.should raise_error('Cannot send data before onopen callback')
+        done
+      }
+
+      # 2. Connect a dumb TCP connection (will not send handshake)
+      EM.connect('0.0.0.0', 12345, EM::Connection)
+    }
+  end
+
+  it "should allow the server to be started inside an existing EM" do
+    em {
+      EM.add_timer(0.1) do
+        http = EM::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
+        http.errback { |e| done }
+        http.callback { fail }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-        ws.onopen {
-          ws.request["path"].should == "/"
-          ws.request["query"].should == {}
+      start_server do |ws|
+        ws.onopen { |handshake|
+          headers = handshake.headers
+          headers["Host"].to_s.should == "127.0.0.1:12345"
         }
         ws.onclose {
           ws.state.should == :closed
-          EventMachine.stop
+          done
         }
       end
     }
   end
-  
-  it "should raise an exception if frame sent before handshake complete" do
-    em {
-      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')
-          done
-        }
-      }
 
-      client = EM.connect('0.0.0.0', 12345, EM::Connection)
-    }
+  context "outbound limit set" do
+    it "should close the connection if the limit is reached" do
+      em {
+        start_server(:outbound_limit => 150) do |ws|
+          # Increase the message size by one on each loop
+          ws.onmessage{|msg| ws.send(msg + "x") }
+          ws.onclose{|status|
+            status[:code].should == 1006 # Unclean
+            status[:was_clean].should be_false
+          }
+        end
+
+        EM.add_timer(0.1) do
+          ws = EventMachine::WebSocketClient.connect('ws://127.0.0.1:12345/')
+          ws.callback { ws.send_msg "hello" }
+          ws.disconnect { done } # Server closed the connection
+          ws.stream { |msg|
+            # minus frame size ? (getting 146 max here)
+            msg.data.size.should <= 150
+            # Return back the message
+            ws.send_msg(msg.data)
+          }
+        end
+      }
+    end
   end
 end

data/spec/integration/draft03_spec.rb

@@ -1,5 +1,4 @@
 require 'helper'
-require 'integration/shared_examples'
 
 describe "draft03" do
   include EM::SpecHelper
@@ -35,18 +34,19 @@ describe "draft03" do
     }
   end
 
+  def start_client
+    client = EM.connect('0.0.0.0', 12345, Draft03FakeWebSocketClient)
+    client.send_data(format_request(@request))
+    yield client if block_given?
+    return client
+  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
+    let(:version) { 3 }
+  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_behaves_like "a WebSocket server drafts 3 and above" do
+    let(:version) { 3 }
   end
 
   # These examples are straight from the spec
@@ -54,36 +54,30 @@ describe "draft03" do
   describe "examples from the spec" do
     it "should accept a single-frame text message" do
       em {
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        start_server { |ws|
           ws.onmessage { |msg|
             msg.should == 'Hello'
             done
           }
         }
-
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
-
-        # Send frame
-        connection.onopen {
-          connection.send_data("\x04\x05Hello")
+        start_client { |client|
+          client.onopen {
+            client.send_data("\x04\x05Hello")
+          }
         }
       }
     end
     
     it "should accept a fragmented text message" do
       em {
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        start_server { |ws|
           ws.onmessage { |msg|
             msg.should == 'Hello'
             done
           }
         }
 
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         # Send frame
         connection.onopen {
@@ -95,11 +89,9 @@ describe "draft03" do
     
     it "should accept a ping request and respond with the same body" do
       em {
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws| }
+        start_server
 
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         # Send frame
         connection.onopen {
@@ -118,16 +110,15 @@ describe "draft03" do
       em {
         data = "a" * 256
         
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
-          ws.onmessage { |msg|
+        start_server { |ws|
+          ws.onbinary { |msg|
+            msg.encoding.should == Encoding.find("BINARY") if defined?(Encoding)
             msg.should == data
             done
           }
         }
 
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         # Send frame
         connection.onopen {
@@ -140,16 +131,15 @@ describe "draft03" do
       em {
         data = "a" * 65536
         
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
-          ws.onmessage { |msg|
+        start_server { |ws|
+          ws.onbinary { |msg|
+            msg.encoding.should == Encoding.find("BINARY") if defined?(Encoding)
             msg.should == data
             done
           }
         }
 
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         # Send frame
         connection.onopen {
@@ -162,11 +152,9 @@ describe "draft03" do
   describe "close handling" do
     it "should respond to a new close frame with a close frame" do
       em {
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws| }
+        start_server
 
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         # Send close frame
         connection.onopen {
@@ -181,22 +169,31 @@ describe "draft03" do
       }
     end
 
-    it "should close the connection on receiving a close acknowlegement" do
+    it "should close the connection on receiving a close acknowlegement and call onclose with close code 1005 and was_clean=true (initiated by server)" do
       em {
         ack_received = false
 
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        start_server { |ws|
           ws.onopen {
             # 2. Send a close frame
             EM.next_tick {
-              ws.close_websocket
+              ws.close
             }
           }
+
+          # 5. Onclose event on server
+          ws.onclose { |event|
+            event.should == {
+              :code => 1005,
+              :reason => "",
+              :was_clean => true,
+            }
+            done
+          }
         }
 
         # 1. Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         # 3. Check that close frame recieved and acknowlege it
         connection.onmessage { |frame|
@@ -208,18 +205,39 @@ describe "draft03" do
         # 4. Check that connection is closed _after_ the ack
         connection.onclose {
           ack_received.should == true
-          done
+        }
+      }
+    end
+
+    # it "should repur"
+    #
+    it "should return close code 1005 and was_clean=true after closing handshake (initiated by client)" do
+      em {
+        start_server { |ws|
+          ws.onclose { |event|
+            event.should == {
+              :code => 1005,
+              :reason => "",
+              :was_clean => true,
+            }
+            done
+          }
+        }
+        start_client { |client|
+          client.onopen {
+            client.send_data("\x01\x00")
+          }
         }
       }
     end
 
     it "should not allow data frame to be sent after close frame sent" do
       em {
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        start_server { |ws|
           ws.onopen {
             # 2. Send a close frame
             EM.next_tick {
-              ws.close_websocket
+              ws.close
             }
 
             # 3. Check that exception raised if I attempt to send more data
@@ -233,25 +251,23 @@ describe "draft03" do
         }
 
         # 1. Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        start_client
       }
     end
 
     it "should still respond to control frames after close frame sent" do
       em {
-        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        start_server { |ws|
           ws.onopen {
             # 2. Send a close frame
             EM.next_tick {
-              ws.close_websocket
+              ws.close
             }
           }
         }
 
         # 1. Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        connection.send_data(format_request(@request))
+        connection = start_client
 
         connection.onmessage { |frame|
           if frame == "\x01\x00"
@@ -266,5 +282,17 @@ describe "draft03" do
         }
       }
     end
+
+    it "should report that close codes are not supported" do
+      em {
+        start_server { |ws|
+          ws.onopen {
+            ws.supports_close_codes?.should == false
+            done
+          }
+        }
+        start_client
+      }
+    end
   end
 end