sonixlabs-em-websocket 0.3.7

data/spec/integration/draft06_spec.rb

@@ -0,0 +1,88 @@
+require 'helper'
+require 'integration/client_examples'
+
+describe "draft06" do
+  include EM::SpecHelper
+  default_timeout 1
+
+  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 {
+      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
+          done
+        }
+      }
+    }
+  end
+  
+  it "should accept a single-frame text message (masked)" do
+    em {
+      start_server { |server|
+        server.onmessage { |msg|
+          msg.should == 'Hello'
+          if msg.respond_to?(:encoding)
+            msg.encoding.should == Encoding.find("UTF-8")
+          end
+          done
+        }
+        server.onerror {
+          fail
+        }
+      }
+  
+      start_client { |client|
+        client.onopen {
+          client.send_data("\x00\x00\x01\x00\x84\x05Ielln")
+        }
+      }
+    }
+  end
+
+  it_should_behave_like "a websocket client"
+end

data/spec/integration/draft13_spec.rb

@@ -0,0 +1,75 @@
+require 'helper'
+require 'integration/shared_examples'
+require 'integration/client_examples'
+
+describe "draft13" do
+  include EM::SpecHelper
+  default_timeout 1
+
+  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' => '13'
+      }
+    }
+
+    @response = {
+      :protocol => "HTTP/1.1 101 Switching Protocols\r\n",
+      :headers => {
+        "Upgrade" => "websocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Accept" => "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=",
+      }
+    }
+  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, Draft07FakeWebSocketClient)
+      client.send_data(format_request(@request))
+      yield client if block_given?
+    end
+  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
+          done
+        }
+      end
+    }
+  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
+      }
+    end
+  end
+
+end

data/spec/integration/draft75_spec.rb

@@ -0,0 +1,117 @@
+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
+  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?
+    end
+  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 }
+
+        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
+
+  it "should split multiple messages into separate callbacks" do
+    em {
+      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 { fail }
+        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
+
+  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
+        }
+        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
+
+  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.callback { fail }
+      end
+
+      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |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')
+          EventMachine.stop
+        }
+      end
+    }
+  end
+end

data/spec/integration/draft76_spec.rb

@@ -0,0 +1,230 @@
+require 'helper'
+require 'integration/shared_examples'
+
+describe "WebSocket server draft76" do
+  include EM::SpecHelper
+  default_timeout 1
+
+  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'
+    }
+
+    @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-"
+    }
+  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
+  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))
+        
+        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
+    }
+  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
+          }
+        }
+        
+        # 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
+    }
+  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)
+        }
+  
+        connection.onclose {
+          done
+        }
+      end
+    }
+  end
+
+  it "should handle unreasonable frame lengths by calling onerror callback" do
+    em {
+      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |server|
+        server.onerror { |error|
+          error.should be_an_instance_of EM::WebSocket::DataError
+          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))
+
+      # This particular frame indicates a message length of
+      # 1180591620717411303296 bytes. Such a message would previously cause
+      # a "bignum too big to convert into `long'" error.
+      # However it is clearly unreasonable and should be rejected.
+      client.onopen {
+        client.send_data("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00")
+      }
+    }
+  end
+  
+  it "should handle impossible frames by calling onerror callback" do
+    em {
+      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |server|
+        server.onerror { |error|
+          error.should be_an_instance_of EM::WebSocket::DataError
+          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.onopen {
+        client.send_data("foobar") # Does not start with \x00 or \xff
+      }
+    }
+  end
+
+  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|
+        server.onerror { |error|
+          error.should be_an_instance_of EM::WebSocket::HandshakeError
+          error.message.should == "Invalid HTTP header"
+          done
+        }
+      }
+      
+      client = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
+      client.send_data("This is not a HTTP header\r\n\r\n")
+    }
+  end
+
+  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) { }
+
+        # 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
+        }
+
+        EM.add_timer(0.1) do
+          # Sends second half of the request
+          connection.send_data(data[(data.length / 2)..-1])
+        end
+      end
+    }
+  end
+end

data/spec/integration/shared_examples.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+
+shared_examples_for "a websocket server" do
+  it "should call onerror if an application error raised in onopen" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          raise "application error"
+        }
+
+        ws.onerror { |e|
+          e.message.should == "application error"
+          done
+        }
+      }
+
+      start_client
+    }
+  end
+
+  it "should call onerror if an application error raised in onmessage" do
+    em {
+      start_server { |server|
+        server.onmessage {
+          raise "application error"
+        }
+
+        server.onerror { |e|
+          e.message.should == "application error"
+          done
+        }
+      }
+
+      start_client { |client|
+        client.onopen {
+          client.send('a message')
+        }
+      }
+    }
+  end
+
+  it "should call onerror in an application error raised in onclose" do
+    em {
+      start_server { |server|
+        server.onclose {
+          raise "application error"
+        }
+
+        server.onerror { |e|
+          e.message.should == "application error"
+          done
+        }
+      }
+
+      start_client { |client|
+        client.onopen {
+          EM.add_timer(0.1) {
+            client.close_connection
+          }
+        }
+      }
+    }
+  end
+
+  # Only run these tests on ruby 1.9
+  if "a".respond_to?(:force_encoding)
+    it "should raise error if you try to send non utf8 text data to ws" do
+      em {
+        start_server { |server|
+          server.onopen {
+            # Create a string which claims to be UTF-8 but which is not
+            s = "ê" # utf-8 string
+            s.encode!("ISO-8859-1")
+            s.force_encoding("UTF-8")
+            s.valid_encoding?.should == false # now invalid utf8
+
+            # Send non utf8 encoded data
+            server.send(s)
+          }
+          server.onerror { |error|
+            error.class.should == EventMachine::WebSocket::WebSocketError
+            error.message.should == "Data sent to WebSocket must be valid UTF-8 but was UTF-8 (valid: false)"
+            done
+          }
+        }
+
+        start_client { }
+      }
+    end
+  end
+end