sonixlabs-em-websocket 0.3.7

data/spec/helper.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'rspec'
+require 'em-spec/rspec'
+require 'pp'
+require 'em-http'
+
+require 'em-websocket'
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end
+
+class FakeWebSocketClient < EM::Connection
+  attr_reader :handshake_response, :packets
+
+  def onopen(&blk);     @onopen = blk;    end
+  def onclose(&blk);    @onclose = blk;   end
+  def onerror(&blk);    @onerror = blk;   end
+  def onmessage(&blk);  @onmessage = blk; end
+
+  def initialize
+    @state = :new
+    @packets = []
+  end
+
+  def receive_data(data)
+    # puts "RECEIVE DATA #{data}"
+    if @state == :new
+      @handshake_response = data
+      @onopen.call if @onopen
+      @state = :open
+    else
+      @onmessage.call(data) if @onmessage
+      @packets << data
+    end
+  end
+
+  def send(data)
+    send_data("\x00#{data}\xff")
+  end
+
+  def unbind
+    @onclose.call if @onclose
+  end
+end
+
+class Draft03FakeWebSocketClient < FakeWebSocketClient
+  def send(application_data)
+    frame = ''
+    opcode = 4 # fake only supports text frames
+    byte1 = opcode # since more, rsv1-3 are 0
+    frame << byte1
+
+    length = application_data.size
+    if length <= 125
+      byte2 = length # since rsv4 is 0
+      frame << byte2
+    elsif length < 65536 # write 2 byte length
+      frame << 126
+      frame << [length].pack('n')
+    else # write 8 byte length
+      frame << 127
+      frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+    end
+
+    frame << application_data
+
+    send_data(frame)
+  end
+end
+
+class Draft07FakeWebSocketClient < FakeWebSocketClient
+  def send(application_data)
+    frame = ''
+    opcode = 1 # fake only supports text frames
+    byte1 = opcode | 0b10000000 # since more, rsv1-3 are 0
+    frame << byte1
+
+    mask = 0b10000000
+
+    length = application_data.size
+    if length <= 125
+      byte2 = length # since rsv4 is 0
+      frame << (mask | byte2)
+    elsif length < 65536 # write 2 byte length
+      frame << (mask | 126)
+      frame << [length].pack('n')
+    else # write 8 byte length
+      frame << (mask | 127)
+      frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+    end
+
+    frame << EventMachine::WebSocket::MaskedString.create_masked_string(application_data)
+
+    send_data(frame)
+  end
+end
+
+
+# Wrap EM:HttpRequest in a websocket like interface so that it can be used in the specs with the same interface as FakeWebSocketClient
+class Draft75WebSocketClient
+  def onopen(&blk);     @onopen = blk;    end
+  def onclose(&blk);    @onclose = blk;   end
+  def onerror(&blk);    @onerror = blk;   end
+  def onmessage(&blk);  @onmessage = blk; end
+
+  def initialize
+    @ws = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
+    @ws.errback { @onerror.call if @onerror }
+    @ws.callback { @onopen.call if @onopen }
+    @ws.stream { |msg| @onmessage.call(msg) if @onmessage }
+  end
+
+  def send(message)
+    @ws.send(message)
+  end
+
+  def close_connection
+    @ws.close_connection
+  end
+end
+
+def format_request(r)
+  data = "#{r[:method]} #{r[:path]} HTTP/1.1\r\n"
+  header_lines = r[:headers].map { |k,v| "#{k}: #{v}" }
+  data << [header_lines, '', r[:body]].join("\r\n")
+  data
+end
+
+def format_response(r)
+  data = r[:protocol] || "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+  header_lines = r[:headers].map { |k,v| "#{k}: #{v}" }
+  data << [header_lines, '', r[:body]].join("\r\n")
+  data
+end
+
+def handler(request, secure = false)
+  connection = Object.new
+  EM::WebSocket::HandlerFactory.build(connection, format_request(request), secure)
+end
+
+RSpec::Matchers.define :send_handshake do |response|
+  match do |actual|
+    actual.handshake.lines.sort == format_response(response).lines.sort
+  end
+end

data/spec/integration/client_examples.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+shared_examples_for "a websocket client" do
+  it "should accept a single-frame binary message" do
+    EM.run do
+      start_server { |server|
+        server.onmessage { |msg, type|
+          msg.should == '\xFF\xFF'
+          type.should == :binary
+          EM.stop
+        }
+        server.onerror {
+          failed
+        }
+      }
+
+      options = { :host => '0.0.0.0', :port => 12345, :debug => false }
+      client = EM.connect('0.0.0.0', 12345, EventMachine::WebSocket::ClientConnection, options) do |ws|
+        ws.onopen do
+          ws.send '\xFF\xFF', :binary
+        end
+      end
+    end
+  end
+
+  it "should accept a text message in the same frame as the server handshake response" do
+    EM.run do
+      start_server { |server|
+        server.onopen { server.send 'hello' }
+        server.onerror { failed }
+      }
+      
+      options = { :host => '0.0.0.0', :port => 12345, :debug => false }
+      client = EM.connect( options[:host], options[:port], EventMachine::WebSocket::ClientConnection, options) do |ws|
+        ws.onmessage{ |msg, type| 
+          msg.should == 'hello'
+          type.should == :text
+          EM.stop
+        }
+        
+        EventMachine::add_timer 3 do
+          failed # ran out of time
+        end
+      end
+    end
+  end
+
+end

data/spec/integration/common_spec.rb

@@ -0,0 +1,118 @@
+require 'helper'
+
+# These tests are not specifi 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
+        http.errback { done }
+        http.callback { fail }
+      end
+
+      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
+    }
+  end
+  
+  it "should populate ws.request with appropriate headers" 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.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
+  
+  it "should allow sending and retrieving query string args passed in on the connection request." 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
+        }
+        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
+  
+  it "should ws.response['Query'] to empty hash when no query string params passed in connection URI" 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.request["path"].should == "/"
+          ws.request["query"].should == {}
+        }
+        ws.onclose {
+          ws.state.should == :closed
+          EventMachine.stop
+        }
+      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)
+    }
+  end
+end

data/spec/integration/draft03_spec.rb

@@ -0,0 +1,270 @@
+require 'helper'
+require 'integration/shared_examples'
+
+describe "draft03" 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',
+        'Sec-WebSocket-Draft' => '3'
+      },
+      :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, 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
+    it "should accept a single-frame text message" do
+      em {
+        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |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")
+        }
+      }
+    end
+    
+    it "should accept a fragmented text message" do
+      em {
+        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |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("\x84\x03Hel")
+          connection.send_data("\x00\x02lo")
+        }
+      }
+    end
+    
+    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| }
+
+        # 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("\x02\x05Hello")
+        }
+        
+        connection.onmessage { |frame|
+          next if frame.nil?
+          frame.should == "\x03\x05Hello"
+          done
+        }
+      }
+    end
+    
+    it "should accept a 256 bytes binary message in a single frame" do
+      em {
+        data = "a" * 256
+        
+        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+          ws.onmessage { |msg|
+            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))
+
+        # Send frame
+        connection.onopen {
+          connection.send_data("\x05\x7E\x01\x00" + data)
+        }
+      }
+    end
+    
+    it "should accept a 64KiB binary message in a single frame" do
+      em {
+        data = "a" * 65536
+        
+        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+          ws.onmessage { |msg|
+            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))
+
+        # Send frame
+        connection.onopen {
+          connection.send_data("\x05\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data)
+        }
+      }
+    end
+  end
+
+  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| }
+
+        # 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 close frame
+        connection.onopen {
+          connection.send_data("\x01\x00")
+        }
+
+        # Check that close ack received
+        connection.onmessage { |frame|
+          frame.should == "\x01\x00"
+          done
+        }
+      }
+    end
+
+    it "should close the connection on receiving a close acknowlegement" do
+      em {
+        ack_received = false
+
+        EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+          ws.onopen {
+            # 2. Send a close frame
+            EM.next_tick {
+              ws.close_websocket
+            }
+          }
+        }
+
+        # 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))
+
+        # 3. Check that close frame recieved and acknowlege it
+        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 {
+          ack_received.should == true
+          done
+        }
+      }
+    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|
+          ws.onopen {
+            # 2. Send a close frame
+            EM.next_tick {
+              ws.close_websocket
+            }
+
+            # 3. Check that exception raised if I attempt to send more data
+            EM.add_timer(0.1) {
+              lambda {
+                ws.send('hello world')
+              }.should raise_error(EM::WebSocket::WebSocketError, 'Cannot send data frame since connection is closing')
+              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))
+      }
+    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|
+          ws.onopen {
+            # 2. Send a close frame
+            EM.next_tick {
+              ws.close_websocket
+            }
+          }
+        }
+
+        # 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.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
+            connection.send_data("\x02\x05Hello")
+          else
+            # 4. Check that the pong is received
+            frame.should == "\x03\x05Hello"
+            done
+          end
+        }
+      }
+    end
+  end
+end

data/spec/integration/draft05_spec.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+describe "draft05" 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' => '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 {
+      start_server { |server|
+        server.onopen {
+          server.instance_variable_get(:@handler).class.should == EventMachine::WebSocket::Handler05
+          done
+        }
+      }
+      
+      start_client
+    }
+  end
+end