em-websocket 0.2.1 → 0.3.0

data/spec/integration/draft76_spec.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'integration/shared_examples'
 
 describe "WebSocket server draft76" do
   before :each do
@@ -30,6 +31,20 @@ describe "WebSocket server draft76" do
     }
   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.run do
       EM.add_timer(0.1) do
@@ -39,7 +54,7 @@ describe "WebSocket server draft76" do
         connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
         connection.send_data(format_request(@request))
         
-        connection.onopen = lambda {
+        connection.onopen {
           connection.handshake_response.lines.sort.
             should == format_response(@response).lines.sort
           EM.stop
@@ -58,13 +73,13 @@ describe "WebSocket server draft76" do
         connection.send_data(format_request(@request))
   
         # Send closing frame after handshake complete
-        connection.onopen = lambda {
+        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 = lambda {
+        connection.onclose {
           connection.packets[0].should == 
             EM::WebSocket::Handler76::TERMINATE_STRING
           EM.stop
@@ -88,12 +103,12 @@ describe "WebSocket server draft76" do
         connection.send_data(format_request(@request))
   
         # Send closing frame after handshake complete, followed by another msg
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
           connection.send('foobar')
         }
   
-        connection.onclose = lambda {
+        connection.onclose {
           EM.stop
         }
       end
@@ -114,12 +129,12 @@ describe "WebSocket server draft76" do
         connection.send_data(format_request(@request))
   
         # Send closing frame after handshake complete
-        connection.onopen = lambda {
+        connection.onopen {
           connection.send_data("\000\n\000\377")
           connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
         }
   
-        connection.onclose = lambda {
+        connection.onclose {
           EM.stop
         }
       end
@@ -144,7 +159,7 @@ describe "WebSocket server draft76" do
       # 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 = lambda {
+      client.onopen {
         client.send_data("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00")
       }
     end
@@ -164,7 +179,7 @@ describe "WebSocket server draft76" do
       client = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
       client.send_data(format_request(@request))
 
-      client.onopen = lambda {
+      client.onopen {
         client.send_data("foobar") # Does not start with \x00 or \xff
       }
     end
@@ -196,7 +211,7 @@ describe "WebSocket server draft76" do
         # Sends first half of the request
         connection.send_data(data[0...(data.length / 2)])
 
-        connection.onopen = lambda {
+        connection.onopen {
           connection.handshake_response.lines.sort.
             should == format_response(@response).lines.sort
           EM.stop

data/spec/integration/shared_examples.rb

@@ -0,0 +1,62 @@
+shared_examples_for "a websocket server" do
+  it "should call onerror if an application error raised in onopen" do
+    EM.run {
+      start_server { |ws|
+        ws.onopen {
+          raise "application error"
+        }
+
+        ws.onerror { |e|
+          e.message.should == "application error"
+          EM.stop
+        }
+      }
+
+      start_client
+    }
+  end
+
+  it "should call onerror if an application error raised in onmessage" do
+    EM.run {
+      start_server { |server|
+        server.onmessage {
+          raise "application error"
+        }
+
+        server.onerror { |e|
+          e.message.should == "application error"
+          EM.stop
+        }
+      }
+
+      start_client { |client|
+        client.onopen {
+          client.send('a message')
+        }
+      }
+    }
+  end
+
+  it "should call onerror in an application error raised in onclose" do
+    EM.run {
+      start_server { |server|
+        server.onclose {
+          raise "application error"
+        }
+
+        server.onerror { |e|
+          e.message.should == "application error"
+          EM.stop
+        }
+      }
+
+      start_client { |client|
+        client.onopen {
+          EM.add_timer(0.1) {
+            client.close_connection
+          }
+        }
+      }
+    }
+  end
+end

data/spec/unit/framing_spec.rb

@@ -106,3 +106,58 @@ describe EM::WebSocket::Framing03 do
     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
+end

data/spec/unit/masking_spec.rb

@@ -0,0 +1,18 @@
+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(0, 4).should == "\x00\x01\x00\x00"
+    t.getbytes(1, 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(0).should == 0x53
+    t.getbyte(1).should == nil
+  end
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: em-websocket
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors: 
 - Ilya Grigorik
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-01 00:00:00 +00:00
+date: 2011-05-06 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,10 +21,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 12
-        - 9
         version: 0.12.9
   type: :runtime
   version_requirements: *id001
@@ -40,10 +32,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 1
-        - 1
         version: 2.1.1
   type: :runtime
   version_requirements: *id002
@@ -55,10 +43,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 2
-        - 6
         version: 0.2.6
   type: :development
   version_requirements: *id003
@@ -70,11 +54,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 0
-        - 0
-        version: 2.0.0
+        version: 2.5.0
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -85,8 +65,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id005
@@ -114,25 +92,42 @@ files:
 - examples/multicast.rb
 - examples/test.html
 - lib/em-websocket.rb
+- lib/em-websocket/close03.rb
+- lib/em-websocket/close05.rb
+- lib/em-websocket/close06.rb
+- lib/em-websocket/close75.rb
 - lib/em-websocket/connection.rb
 - lib/em-websocket/debugger.rb
 - lib/em-websocket/framing03.rb
+- lib/em-websocket/framing04.rb
+- lib/em-websocket/framing05.rb
 - lib/em-websocket/framing76.rb
 - lib/em-websocket/handler.rb
 - lib/em-websocket/handler03.rb
+- lib/em-websocket/handler05.rb
+- lib/em-websocket/handler06.rb
 - lib/em-websocket/handler75.rb
 - lib/em-websocket/handler76.rb
 - lib/em-websocket/handler_factory.rb
+- lib/em-websocket/handshake04.rb
 - lib/em-websocket/handshake75.rb
 - lib/em-websocket/handshake76.rb
+- lib/em-websocket/masking04.rb
+- lib/em-websocket/message_processor_03.rb
+- lib/em-websocket/message_processor_06.rb
 - lib/em-websocket/version.rb
 - lib/em-websocket/websocket.rb
 - spec/helper.rb
+- spec/integration/common_spec.rb
 - spec/integration/draft03_spec.rb
+- spec/integration/draft05_spec.rb
+- spec/integration/draft06_spec.rb
+- spec/integration/draft75_spec.rb
 - spec/integration/draft76_spec.rb
+- spec/integration/shared_examples.rb
 - spec/unit/framing_spec.rb
 - spec/unit/handler_spec.rb
-- spec/websocket_spec.rb
+- spec/unit/masking_spec.rb
 has_rdoc: true
 homepage: http://github.com/igrigorik/em-websocket
 licenses: []
@@ -147,28 +142,29 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: em-websocket
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: EventMachine based WebSocket server
 test_files: 
 - spec/helper.rb
+- spec/integration/common_spec.rb
 - spec/integration/draft03_spec.rb
+- spec/integration/draft05_spec.rb
+- spec/integration/draft06_spec.rb
+- spec/integration/draft75_spec.rb
 - spec/integration/draft76_spec.rb
+- spec/integration/shared_examples.rb
 - spec/unit/framing_spec.rb
 - spec/unit/handler_spec.rb
-- spec/websocket_spec.rb
+- spec/unit/masking_spec.rb

data/spec/websocket_spec.rb

@@ -1,210 +0,0 @@
-require 'helper'
-
-describe EventMachine::WebSocket do
-
-  it "should automatically complete WebSocket handshake" do
-    EM.run do
-      MSG = "Hello World!"
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-        http.errback { failed }
-        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
-  end
-
-  it "should fail on non WebSocket requests" do
-    EM.run do
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
-        http.errback { failed }
-        http.callback {
-          http.response_header.status.should == 400
-          EventMachine.stop
-        }
-      end
-
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
-    end
-  end
-
-  it "should split multiple messages into separate callbacks" do
-    EM.run do
-      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 { failed }
-        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
-  end
-
-  it "should call onclose callback when client closes connection" do
-    EM.run do
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-        http.errback { failed }
-        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
-  end
-
-  it "should call onerror callback with raised exception and close connection on bad handshake" do
-    EM.run do
-      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 { failed }
-      end
-
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-        ws.onopen { failed }
-        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
-
-  it "should populate ws.request with appropriate headers" do
-    EM.run do
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-        http.errback { failed }
-        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
-  end
-
-  it "should allow sending and retrieving query string args passed in on the connection request." do
-    EM.run do
-      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 { failed }
-        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
-  end
-
-  it "should ws.response['Query'] to empty hash when no query string params passed in connection URI" do
-    EM.run do
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
-        http.errback { failed }
-        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
-  end
-
-  it "should raise an exception if frame sent before handshake complete" do
-    EM.run {
-      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')
-          EM.stop
-        }
-      }
-
-      client = EM.connect('0.0.0.0', 12345, EM::Connection)
-    }
-  end
-end