sonixlabs-em-websocket 0.3.8 → 0.5.1.1

data/spec/integration/draft05_spec.rb

@@ -20,28 +20,30 @@ describe "draft05" do
       }
     }
   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 = EM.connect('0.0.0.0', 12345, Draft05FakeWebSocketClient)
     client.send_data(format_request(@request))
     yield client if block_given?
+    return client
   end
   
-  it "should open connection" do
+  it_behaves_like "a websocket server" do
+    let(:version) { 5 }
+  end
+
+  it_behaves_like "a WebSocket server drafts 3 and above" do
+    let(:version) { 5 }
+  end
+
+  it "should report that close codes are not supported" do
     em {
-      start_server { |server|
-        server.onopen {
-          server.instance_variable_get(:@handler).class.should == EventMachine::WebSocket::Handler05
+      start_server { |ws|
+        ws.onopen {
+          ws.supports_close_codes?.should == false
           done
         }
       }
-      
       start_client
     }
   end

data/spec/integration/draft06_spec.rb

@@ -1,5 +1,4 @@
 require 'helper'
-require 'integration/client_examples'
 
 describe "draft06" do
   include EM::SpecHelper
@@ -27,22 +26,26 @@ describe "draft06" do
         "Upgrade" => "websocket",
         "Connection" => "Upgrade",
         "Sec-WebSocket-Accept" => "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=",
+        "Sec-WebSocket-Protocol" => "sample",
       }
     }
   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 = EM.connect('0.0.0.0', 12345, Draft05FakeWebSocketClient)
     client.send_data(format_request(@request))
     yield client if block_given?
+    return client
   end
   
+  it_behaves_like "a websocket server" do
+    let(:version) { 6 }
+  end
+
+  it_behaves_like "a WebSocket server drafts 3 and above" do
+    let(:version) { 6 }
+  end
+
   it "should open connection" do
     em {
       start_server { |server|
@@ -84,5 +87,59 @@ describe "draft06" do
     }
   end
 
-  it_should_behave_like "a websocket client"
+  it "should return close code and reason if closed via handshake" do
+    em {
+      start_server { |ws|
+        ws.onclose { |event|
+          # 2. Receive close event in server
+          event.should == {
+            :code => 4004,
+            :reason => "close reason",
+            :was_clean => true,
+          }
+          done
+        }
+      }
+      start_client { |client|
+        client.onopen {
+          # 1: Send close handshake
+          close_data = [4004].pack('n')
+          close_data << "close reason"
+          client.send_frame(:close, close_data)
+        }
+      }
+    }
+  end
+
+  it "should return close code 1005 if no code was specified" do
+    em {
+      start_server { |ws|
+        ws.onclose { |event|
+          event.should == {
+            :code => 1005,
+            :reason => "",
+            :was_clean => true,
+          }
+          done
+        }
+      }
+      start_client { |client|
+        client.onopen {
+          client.send_frame(:close, '')
+        }
+      }
+    }
+  end
+
+  it "should report that close codes are supported" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          ws.supports_close_codes?.should == true
+          done
+        }
+      }
+      start_client
+    }
+  end
 end

data/spec/integration/draft13_spec.rb

@@ -1,6 +1,6 @@
+# encoding: BINARY
+
 require 'helper'
-require 'integration/shared_examples'
-require 'integration/client_examples'
 
 describe "draft13" do
   include EM::SpecHelper
@@ -28,48 +28,78 @@ describe "draft13" do
         "Upgrade" => "websocket",
         "Connection" => "Upgrade",
         "Sec-WebSocket-Accept" => "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=",
+        "Sec-WebSocket-Protocol" => "sample",
       }
     }
   end
 
+  def start_client
+    client = EM.connect('0.0.0.0', 12345, Draft07FakeWebSocketClient)
+    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) { 13 }
+  end
 
-    def start_client
-      client = EM.connect('0.0.0.0', 12345, Draft07FakeWebSocketClient)
-      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) { 13 }
   end
 
   it "should send back the correct handshake response" do
     em {
-      EM.add_timer(0.1) do
-        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { }
-        
-        # Create a fake client which sends draft 07 handshake
-        connection = EM.connect('0.0.0.0', 12345, Draft07FakeWebSocketClient)
-        connection.send_data(format_request(@request))
-        
-        connection.onopen {
-          connection.handshake_response.lines.sort.
-            should == format_response(@response).lines.sort
+      start_server
+
+      connection = start_client
+
+      connection.onopen {
+        connection.handshake_response.lines.sort.
+          should == format_response(@response).lines.sort
+        done
+      }
+    }
+  end
+
+  # TODO: This test would be much nicer with a real websocket client...
+  it "should support sending pings and binding to onpong" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          ws.should be_pingable
+          EM.next_tick {
+            ws.ping('hello').should == true
+          }
+
+        }
+        ws.onpong { |data|
+          data.should == 'hello'
           done
         }
-      end
+      }
+
+      connection = start_client
+
+      # Confusing, fake onmessage means any data after the handshake
+      connection.onmessage { |data|
+        # This is what a ping looks like
+        data.should == "\x89\x05hello"
+        # This is what a pong looks like
+        connection.send_data("\x8a\x05hello")
+      }
     }
   end
 
-  it_should_behave_like "a websocket client" do
-    def start_server
-      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
-        yield ws
+  it "should report that close codes are supported" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          ws.supports_close_codes?.should == true
+          done
+        }
       }
-    end
+      start_client
+    }
   end
-
 end

data/spec/integration/draft75_spec.rb

@@ -1,5 +1,4 @@
 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 
@@ -9,38 +8,35 @@ describe "WebSocket server draft75" do
   include EM::SpecHelper
   default_timeout 1
 
-  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?
+    return client
+  end
 
-    def start_client
-      client = Draft75WebSocketClient.new
-      yield client if block_given?
-    end
+  it_behaves_like "a websocket server" do
+    let(:version) { 75 }
   end
 
   it "should automatically complete WebSocket handshake" do
     em {
       MSG = "Hello World!"
       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 }
+        ws = EventMachine::WebSocketClient.connect('ws://127.0.0.1:12345/')
+        ws.errback { fail }
+        ws.callback { }
 
-        http.stream { |msg|
-          msg.should == MSG
+        ws.stream { |msg|
+          msg.data.should == MSG
           EventMachine.stop
         }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
+      start_server { |ws|
         ws.onopen {
           ws.send MSG
         }
-      end
+      }
     }
   end
 
@@ -50,17 +46,16 @@ describe "WebSocket server draft75" do
       received = []
 
       EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-        http.errback { fail }
-        http.stream {|msg|}
-        http.callback {
-          http.response_header.status.should == 101
-          http.send messages[0]
-          http.send messages[1]
+        ws = EventMachine::WebSocketClient.connect('ws://127.0.0.1:12345/')
+        ws.errback { fail }
+        ws.stream {|msg|}
+        ws.callback {
+          ws.send_msg messages[0]
+          ws.send_msg messages[1]
         }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
+      start_server { |ws|
         ws.onopen {}
         ws.onclose {}
         ws.onmessage {|msg|
@@ -69,49 +64,60 @@ describe "WebSocket server draft75" do
 
           EventMachine.stop if received.size == messages.size
         }
-      end
+      }
     }
   end
 
   it "should call onclose callback when client closes connection" 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
+        ws = EventMachine::WebSocketClient.connect('ws://127.0.0.1:12345/')
+        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|
+      start_server { |ws|
         ws.onopen {}
         ws.onclose {
           ws.state.should == :closed
           EventMachine.stop
         }
-      end
+      }
     }
   end
 
   it "should call onerror callback with raised exception and close connection on bad handshake" do
     em {
       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 = EM::HttpRequest.new('http://127.0.0.1:12345/').get
+        http.errback { }
         http.callback { fail }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
+      start_server { |ws|
         ws.onopen { fail }
         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')
+          e.message.should match('Not an upgrade request')
           EventMachine.stop
         }
-      end
+      }
+    }
+  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

data/spec/integration/draft76_spec.rb

@@ -1,5 +1,6 @@
+# encoding: BINARY
+
 require 'helper'
-require 'integration/shared_examples'
 
 describe "WebSocket server draft76" do
   include EM::SpecHelper
@@ -33,130 +34,109 @@ describe "WebSocket server draft76" do
       :body => "8jKS\'y:G*Co,Wxa-"
     }
   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, FakeWebSocketClient)
-      client.send_data(format_request(@request))
-      yield client if block_given?
-    end
+  def start_client
+    client = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
+    client.send_data(format_request(@request))
+    yield client if block_given?
+    return client
+  end
+
+  it_behaves_like "a websocket server" do
+    let(:version) { 76 }
   end
 
   it "should send back the correct handshake response" do
     em {
-      EM.add_timer(0.1) do
-        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { }
-        
-        # 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_server
+
+      start_client { |connection|
         connection.onopen {
           connection.handshake_response.lines.sort.
             should == format_response(@response).lines.sort
           done
         }
-      end
+      }
     }
   end
   
   it "should send closing frame back and close the connection after recieving closing frame" do
     em {
-      EM.add_timer(0.1) do
-        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { }
-  
-        # 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 closing frame after handshake complete
-        connection.onopen {
-          connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
-        }
-  
-        # Check that this causes a termination string to be returned and the 
-        # connection close
-        connection.onclose {
-          connection.packets[0].should == 
-            EM::WebSocket::Handler76::TERMINATE_STRING
-          done
-        }
-      end
+      start_server
+
+      connection = start_client
+
+      # Send closing frame after handshake complete
+      connection.onopen {
+        connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
+      }
+
+      # Check that this causes a termination string to be returned and the
+      # connection close
+      connection.onclose {
+        connection.packets[0].should ==
+          EM::WebSocket::Handler76::TERMINATE_STRING
+        done
+      }
     }
   end
   
   it "should ignore any data received after the closing frame" do
     em {
-      EM.add_timer(0.1) do
-        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
-          # Fail if foobar message is received
-          ws.onmessage { |msg|
-            fail
-          }
+      start_server { |ws|
+        # Fail if foobar message is received
+        ws.onmessage { |msg|
+          fail
         }
-        
-        # 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 closing frame after handshake complete, followed by another msg
-        connection.onopen {
-          connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
-          connection.send('foobar')
-        }
-  
-        connection.onclose {
-          done
-        }
-      end
+      }
+
+      connection = start_client
+
+      # Send closing frame after handshake complete, followed by another msg
+      connection.onopen {
+        connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
+        connection.send('foobar')
+      }
+
+      connection.onclose {
+        done
+      }
     }
   end
 
   it "should accept null bytes within the frame after a line return" do
     em {
-      EM.add_timer(0.1) do
-        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
-          ws.onmessage { |msg|
-            msg.should == "\n\000" 
-          }
-        }
-  
-        # 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 closing frame after handshake complete
-        connection.onopen {
-          connection.send_data("\000\n\000\377")
-          connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
+      start_server { |ws|
+        ws.onmessage { |msg|
+          msg.should == "\n\000"
         }
-  
-        connection.onclose {
-          done
-        }
-      end
+      }
+
+      connection = start_client
+
+      # Send closing frame after handshake complete
+      connection.onopen {
+        connection.send_data("\000\n\000\377")
+        connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
+      }
+
+      connection.onclose {
+        done
+      }
     }
   end
 
   it "should handle unreasonable frame lengths by calling onerror callback" do
     em {
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |server|
+      start_server { |server|
         server.onerror { |error|
-          error.should be_an_instance_of EM::WebSocket::DataError
+          error.should be_an_instance_of EM::WebSocket::WSMessageTooBigError
           error.message.should == "Frame length too long (1180591620717411303296 bytes)"
           done
         }
       }
 
-      # Create a fake client which sends draft 76 handshake
-      client = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-      client.send_data(format_request(@request))
+      client = start_client
 
       # This particular frame indicates a message length of
       # 1180591620717411303296 bytes. Such a message would previously cause
@@ -170,17 +150,15 @@ describe "WebSocket server draft76" do
   
   it "should handle impossible frames by calling onerror callback" do
     em {
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |server|
+      start_server { |server|
         server.onerror { |error|
-          error.should be_an_instance_of EM::WebSocket::DataError
+          error.should be_an_instance_of EM::WebSocket::WSProtocolError
           error.message.should == "Invalid frame received"
           done
         }
       }
 
-      # Create a fake client which sends draft 76 handshake
-      client = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-      client.send_data(format_request(@request))
+      client = start_client
 
       client.onopen {
         client.send_data("foobar") # Does not start with \x00 or \xff
@@ -190,10 +168,10 @@ describe "WebSocket server draft76" do
 
   it "should handle invalid http requests by raising HandshakeError passed to onerror callback" do
     em {
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |server|
+      start_server { |server|
         server.onerror { |error|
           error.should be_an_instance_of EM::WebSocket::HandshakeError
-          error.message.should == "Invalid HTTP header"
+          error.message.should == "Invalid HTTP header: Could not parse data entirely (1 != 29)"
           done
         }
       }
@@ -205,26 +183,52 @@ describe "WebSocket server draft76" do
 
   it "should handle handshake request split into two TCP packets" do
     em {
-      EM.add_timer(0.1) do
-        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { }
+      start_server
 
-        # Create a fake client which sends draft 76 handshake
-        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
-        data = format_request(@request)
-        # Sends first half of the request
-        connection.send_data(data[0...(data.length / 2)])
+      # Create a fake client which sends draft 76 handshake
+      connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
+      data = format_request(@request)
+      # Sends first half of the request
+      connection.send_data(data[0...(data.length / 2)])
+
+      connection.onopen {
+        connection.handshake_response.lines.sort.
+          should == format_response(@response).lines.sort
+        done
+      }
 
-        connection.onopen {
-          connection.handshake_response.lines.sort.
-            should == format_response(@response).lines.sort
+      EM.add_timer(0.1) do
+        # Sends second half of the request
+        connection.send_data(data[(data.length / 2)..-1])
+      end
+    }
+  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
 
-        EM.add_timer(0.1) do
-          # Sends second half of the request
-          connection.send_data(data[(data.length / 2)..-1])
-        end
-      end
+  it "should call onclose when the server closes the connection [antiregression]" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          EM.add_timer(0.1) {
+            ws.close()
+          }
+        }
+        ws.onclose {
+          done
+        }
+      }
+      start_client
     }
   end
 end