sonixlabs-em-websocket 0.3.7

data/spec/unit/framing_spec.rb

@@ -0,0 +1,325 @@
+require 'helper'
+
+describe EM::WebSocket::Framing03 do
+  class FramingContainer
+    include EM::WebSocket::Framing03
+    
+    def <<(data)
+      @data << data
+      process_data(data)
+    end
+
+    def debug(*args); end
+  end
+  
+  before :each do
+    @f = FramingContainer.new
+    @f.initialize_framing
+  end
+  
+  describe "basic examples" do
+    it "connection close" do
+      @f.should_receive(:message).with(:close, '', '')
+      @f << 0b00000001
+      @f << 0b00000000
+    end
+    
+    it "ping" do
+      @f.should_receive(:message).with(:ping, '', '')
+      @f << 0b00000010
+      @f << 0b00000000
+    end
+    
+    it "pong" do
+      @f.should_receive(:message).with(:pong, '', '')
+      @f << 0b00000011
+      @f << 0b00000000
+    end
+    
+    it "text" do
+      @f.should_receive(:message).with(:text, '', 'foo')
+      @f << 0b00000100
+      @f << 0b00000011
+      @f << 'foo'
+    end
+    
+    it "Text in two frames" do
+      @f.should_receive(:message).with(:text, '', 'hello world')
+      @f << 0b10000100
+      @f << 0b00000110
+      @f << "hello "
+      @f << 0b00000000
+      @f << 0b00000101
+      @f << "world"
+    end
+    
+    it "2 byte extended payload length text frame" do
+      data = 'a' * 256
+      @f.should_receive(:message).with(:text, '', data)
+      @f << 0b00000100 # Single frame, text
+      @f << 0b01111110 # Length 126 (so read 2 bytes)
+      @f << 0b00000001 # Two bytes in network byte order (256)
+      @f << 0b00000000
+      @f << data
+    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 "a single-frame text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x04\x05Hello"
+    end
+    
+    it "a fragmented text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x84\x03Hel"
+      @f << "\x00\x02lo"
+    end
+    
+    it "Ping request and response" do
+      @f.should_receive(:message).with(:ping, '', 'Hello')
+      @f << "\x02\x05Hello"
+    end
+    
+    it "256 bytes binary message in a single frame" do
+      data = "a"*256
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x05\x7E\x01\x00" + data
+    end
+    
+    it "64KiB binary message in a single frame" do
+      data = "a"*65536
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x05\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data
+    end
+  end
+
+  describe "other tests" do
+    it "should accept a fragmented unmasked text message in 3 frames" do
+      @f.should_receive(:message).with(:text, '', 'Hello world')
+      @f << "\x84\x03Hel"
+      @f << "\x80\x02lo"
+      @f << "\x00\x06 world"
+    end
+  end
+
+  describe "error cases" do
+    it "should raise an exception on continuation frame without preceeding more frame" do
+      lambda {
+        @f << 0b00000000 # Single frame, continuation
+        @f << 0b00000001 # Length 1
+        @f << 'f'
+      }.should raise_error(EM::WebSocket::WebSocketError, 'Continuation frame not expected')
+    end
+  end
+end
+
+# These examples are straight from the spec
+# http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-03#section-4.6
+describe EM::WebSocket::Framing04 do
+  class FramingContainer04
+    include EM::WebSocket::Framing04
+
+    def <<(data)
+      @data << data
+      process_data(data)
+    end
+
+    def debug(*args); end
+  end
+
+  before :each do
+    @f = FramingContainer04.new
+    @f.initialize_framing
+  end
+
+  describe "examples from the spec" do
+    it "a single-frame text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x84\x05\x48\x65\x6c\x6c\x6f" # "\x84\x05Hello"
+    end
+
+    it "a fragmented text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x04\x03Hel"
+      @f << "\x80\x02lo"
+    end
+
+    it "Ping request" do
+      @f.should_receive(:message).with(:ping, '', 'Hello')
+      @f << "\x82\x05Hello"
+    end
+
+    it "a pong response" do
+      @f.should_receive(:message).with(:pong, '', 'Hello')
+      @f << "\x83\x05Hello"
+    end
+
+    it "256 bytes binary message in a single frame" do
+      data = "a"*256
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x85\x7E\x01\x00" + data
+    end
+
+    it "64KiB binary message in a single frame" do
+      data = "a"*65536
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x85\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data
+    end
+  end
+
+  describe "other tests" do
+    it "should accept a fragmented unmasked text message in 3 frames" do
+      @f.should_receive(:message).with(:text, '', 'Hello world')
+      @f << "\x04\x03Hel"
+      @f << "\x00\x02lo"
+      @f << "\x80\x06 world"
+    end
+  end
+end
+
+describe EM::WebSocket::Framing07 do
+  class FramingContainer07
+    include EM::WebSocket::Framing07
+
+    def <<(data)
+      @data << data
+      process_data(data)
+    end
+
+    def debug(*args); end
+  end
+
+  before :each do
+    @f = FramingContainer07.new
+    @f.initialize_framing
+  end
+
+  # These examples are straight from the spec
+  # http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07#section-4.6
+  # NOTE I modified these to be compliant with the rule that client data must be masked
+  describe "server side" do
+    describe "examples from the spec" do
+      it "rejects a single-frame unmasked text message from the client" do
+        lambda {
+          @f << "\x81\x05\x48\x65\x6c\x6c\x6f" # "\x84\x05Hello"
+        }.should raise_error(EventMachine::WebSocket::WebSocketError, 'Data from client must be masked')
+      end
+
+      it "a single-frame masked text message" do
+        @f.should_receive(:message).with(:text, '', 'Hello')
+        @f << "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58" # "\x84\x05Hello"
+      end
+
+      it "a fragmented masked text message" do
+        @f.should_receive(:message).with(:text, '', 'Hello')
+        @f << "\x01\x83\x01\x01\x01\x01Idm" # with mask x01x01x01x01, Hello -> Idmmn
+        @f << "\x80\x82\x01\x01\x01\x01mn"
+      end
+
+      it "Ping request" do
+        @f.should_receive(:message).with(:ping, '', 'Hello')
+        @f << "\x89\x85\x01\x01\x01\x01Idmmn"
+      end
+
+      it "a pong response" do
+        @f.should_receive(:message).with(:pong, '', 'Hello')
+        @f << "\x8a\x85\x01\x01\x01\x01Idmmn"
+      end
+
+      it "256 bytes binary message in a single masked frame" do
+        data = "b"*256
+        masked_data = "c"*256
+        @f.should_receive(:message).with(:binary, '', data)
+        @f << "\x82\xFE\x01\x00\x01\x01\x01\x01" + masked_data
+      end
+
+      it "64KiB binary message in a single masked frame" do
+        data = "b"*65536
+        masked_data = "c"*65536
+        @f.should_receive(:message).with(:binary, '', data)
+        @f << "\x82\xFF\x00\x00\x00\x00\x00\x01\x00\x00\x01\x01\x01\x01" + masked_data
+      end
+    end
+
+    describe "other tests" do
+      it "should raise a DataError if an invalid frame type is requested" do
+        lambda {
+          # Opcode 3 is not supported by this draft
+          @f << "\x83\x85\x01\x01\x01\x01Idmmn"
+        }.should raise_error(EventMachine::WebSocket::DataError, "Unknown opcode")
+      end
+
+      it "should accept a fragmented masked text message in 3 frames" do
+        @f.should_receive(:message).with(:text, '', 'Hello world')
+        @f << "\x01\x83\x01\x01\x01\x01Idm"
+        @f << "\x00\x82\x01\x01\x01\x01mn"
+        @f << "\x80\x86\x01\x01\x01\x01\x21vnsme"
+      end
+    end
+  end
+
+  describe "client side" do
+    before do
+      @f.mask_outbound_messages = true
+      @f.require_masked_inbound_messages = false
+    end
+    describe "examples from the spec" do
+      it "accepts a single-frame unmasked text message from the client" do
+        @f.should_receive(:message).with(:text, '', 'Hello')
+        @f << "\x81\x05\x48\x65\x6c\x6c\x6f" # "\x84\x05Hello"
+      end
+
+      it "a single-frame masked text message" do
+        @f.should_receive(:message).with(:text, '', 'Hello')
+        @f << "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58" # "\x84\x05Hello"
+      end
+
+      it "a fragmented unmasked text message" do
+        @f.should_receive(:message).with(:text, '', 'Hello')
+        @f << "\x01\x03\Hel"
+        @f << "\x80\x02\lo"
+      end
+
+      it "Ping request" do
+        @f.should_receive(:message).with(:ping, '', 'Hello')
+        @f << "\x89\x05Hello"
+      end
+
+      it "a pong response" do
+        @f.should_receive(:message).with(:pong, '', 'Hello')
+        @f << "\x8a\x05Hello"
+      end
+
+      it "256 bytes binary message in a single unmasked frame" do
+        data = "a"*256
+        @f.should_receive(:message).with(:binary, '', data)
+        @f << "\x82\x7E\x01\x00" + data
+      end
+
+      it "64KiB binary message in a single unmasked frame" do
+        data = "a"*65536
+        @f.should_receive(:message).with(:binary, '', data)
+        @f << "\x82\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data
+      end
+    end
+
+    describe "other tests" do
+      it "should raise a DataError if an invalid frame type is requested" do
+        lambda {
+          # Opcode 3 is not supported by this draft
+          @f << "\x83\x05Hello"
+        }.should raise_error(EventMachine::WebSocket::DataError, "Unknown opcode")
+      end
+
+      it "should accept a fragmented unmasked text message in 3 frames" do
+        @f.should_receive(:message).with(:text, '', 'Hello world')
+        @f << "\x01\x03Hel"
+        @f << "\x00\x02lo"
+        @f << "\x80\x06 world"
+      end
+    end
+  end
+end

data/spec/unit/handler_spec.rb

@@ -0,0 +1,147 @@
+require 'helper'
+
+describe "EventMachine::WebSocket::Handler" do
+  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'
+    }
+    @secure_request = @request.merge(:port => 443)
+
+    @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-"
+    }
+    @secure_response = @response.merge(:headers => @response[:headers].merge('Sec-WebSocket-Location' => "wss://example.com/demo"))
+  end
+
+  it "should handle good request" do
+    handler(@request).should send_handshake(@response)
+  end
+
+  it "should handle good request to secure default port if secure mode is enabled" do
+    handler(@secure_request, true).should send_handshake(@secure_response)
+  end
+
+  it "should not handle good request to secure default port if secure mode is disabled" do
+    handler(@secure_request, false).should_not send_handshake(@secure_response)
+  end
+
+  it "should handle good request on nondefault port" do
+    @request[:port] = 8081
+    @request[:headers]['Host'] = 'example.com:8081'
+    @response[:headers]['Sec-WebSocket-Location'] =
+      'ws://example.com:8081/demo'
+
+    handler(@request).should send_handshake(@response)
+  end
+
+  it "should handle good request to secure nondefault port" do
+    @secure_request[:port] = 8081
+    @secure_request[:headers]['Host'] = 'example.com:8081'
+    @secure_response[:headers]['Sec-WebSocket-Location'] = 'wss://example.com:8081/demo'
+    handler(@secure_request, true).should send_handshake(@secure_response)
+  end
+
+  it "should handle good request with no protocol" do
+    @request[:headers].delete('Sec-WebSocket-Protocol')
+    @response[:headers].delete("Sec-WebSocket-Protocol")
+
+    handler(@request).should send_handshake(@response)
+  end
+
+  it "should handle extra headers by simply ignoring them" do
+    @request[:headers]['EmptyValue'] = ""
+    @request[:headers]['AKey'] = "AValue"
+
+    handler(@request).should send_handshake(@response)
+  end
+  
+  it "should raise error on HTTP request" do
+    @request[:headers] = {
+      'Host' => 'www.google.com',
+      'User-Agent' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 GTB6 GTBA',
+      'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Language' => 'en-us,en;q=0.5',
+      'Accept-Encoding' => 'gzip,deflate',
+      'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+      'Keep-Alive' => '300',
+      'Connection' => 'keep-alive',
+    }
+    
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  it "should raise error on wrong method" do
+    @request[:method] = 'POST'
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  it "should raise error if upgrade header incorrect" do
+    @request[:headers]['Upgrade'] = 'NonWebSocket'
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  it "should raise error if Sec-WebSocket-Protocol is empty" do
+    @request[:headers]['Sec-WebSocket-Protocol'] = ''
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  %w[Sec-WebSocket-Key1 Sec-WebSocket-Key2].each do |header|
+    it "should raise error if #{header} has zero spaces" do
+      @request[:headers][header] = 'nospaces'
+
+      lambda {
+        handler(@request).handshake
+      }.should raise_error(EM::WebSocket::HandshakeError, 'Websocket Key1 or Key2 does not contain spaces - this is a symptom of a cross-protocol attack')
+    end
+  end
+
+  it "should raise error if spaces do not divide numbers in Sec-WebSocket-Key* " do
+    @request[:headers]['Sec-WebSocket-Key2'] = '12998 5 Y3 1.P00'
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError, 'Invalid Key "12998 5 Y3 1.P00"')
+  end
+
+  it "should leave request with incomplete header" do
+    data = format_request(@request)
+    # Sends only half of the request
+    EM::WebSocket::HandlerFactory.build(mock(EM::WebSocket::Connection), data[0...(data.length / 2)]).should == nil
+  end
+
+  it "should leave request with incomplete third key" do
+    data = format_request(@request)
+    # Removes last two bytes of the third key
+    EM::WebSocket::HandlerFactory.build(mock(EM::WebSocket::Connection), data[0...(data.length - 2)]).should == nil
+  end
+end

data/spec/unit/masking_spec.rb

@@ -0,0 +1,27 @@
+# encoding: BINARY
+
+require 'helper'
+
+describe EM::WebSocket::MaskedString do
+  it "should allow reading 4 byte mask and unmasking byte / bytes" do
+    t = EM::WebSocket::MaskedString.new("\x00\x00\x00\x01\x00\x01\x00\x01")
+    t.read_mask
+    t.getbyte(3).should == 0x00
+    t.getbytes(4, 4).should == "\x00\x01\x00\x00"
+    t.getbytes(5, 3).should ==     "\x01\x00\x00"
+  end
+
+  it "should return nil from getbyte if index requested is out of range" do
+    t = EM::WebSocket::MaskedString.new("\x00\x00\x00\x00\x53")
+    t.read_mask
+    t.getbyte(4).should == 0x53
+    t.getbyte(5).should == nil
+  end
+  
+  it "should allow switching masking on and off" do
+    t = EM::WebSocket::MaskedString.new("\x02\x00\x00\x00\x03")
+    t.getbyte(4).should == 0x03
+    t.read_mask
+    t.getbyte(4).should == 0x01
+  end
+end

data/spec/unit/message_processor_spec.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+describe EM::WebSocket::MessageProcessor06 do
+  class MessageProcessorContainer06
+    attr_accessor :connection
+    include EM::WebSocket::MessageProcessor06
+    def debug(*args); end    
+  end
+  
+  before :each do
+    @mp = MessageProcessorContainer06.new
+    @mp.connection = Object.new
+  end
+  
+  describe "#message" do
+    it "accepts a close"
+    it "accepts a ping"
+    
+    it "accepts a pong" do
+      @mp.connection.should_receive(:trigger_on_message).with(:rock, :pong)
+      @mp.message :pong, :fraggle, :rock
+    end
+
+    it "accepts a binary message" do
+      @mp.connection.should_receive(:trigger_on_message).with(:rock, :binary)
+      @mp.message :binary, :fraggle, :rock
+    end
+    
+    it "accepts a non-UTF8 text message"
+    
+    it "accepts a text message" do
+      @mp.connection.should_receive(:trigger_on_message).with(:rock, :text)
+      @mp.message :text, :fraggle, :rock
+    end    
+  end
+end