sonixlabs-em-websocket 0.3.8 → 0.5.1.1

data/spec/integration/gte_03_examples.rb

@@ -0,0 +1,42 @@
+shared_examples_for "a WebSocket server drafts 3 and above" do
+  it "should force close connections after a timeout if close handshake is not sent by the client" do
+    em {
+      server_onerror_fired = false
+      server_onclose_fired = false
+      client_got_close_handshake = false
+      
+      start_server(:close_timeout => 0.1) { |ws|
+        ws.onopen {
+          # 1: Send close handshake to client
+          EM.next_tick { ws.close(4999, "Close message") }
+        }
+        
+        ws.onerror { |e|
+          # 3: Client should receive onerror
+          e.class.should == EM::WebSocket::WSProtocolError
+          e.message.should == "Close handshake un-acked after 0.1s, closing tcp connection"
+          server_onerror_fired = true
+        }
+        
+        ws.onclose {
+          server_onclose_fired = true
+        }
+      }
+      start_client { |client|
+        client.onmessage { |msg|
+          # 2: Client does not respond to close handshake (the fake client 
+          # doesn't understand them at all hence this is in onmessage)
+          msg.should =~ /Close message/ if version >= 6
+          client_got_close_handshake = true
+        }
+        
+        client.onclose {
+          server_onerror_fired.should == true
+          server_onclose_fired.should == true
+          client_got_close_handshake.should == true
+          done
+        }
+      }
+    }
+  end
+end

data/spec/integration/shared_examples.rb

@@ -1,6 +1,127 @@
 # encoding: UTF-8
 
+# These tests are run against all draft versions
+#
 shared_examples_for "a websocket server" do
+  it "should expose the protocol version" do
+    em {
+      start_server { |ws|
+        ws.onopen { |handshake|
+          handshake.protocol_version.should == version
+          done
+        }
+      }
+
+      start_client
+    }
+  end
+
+  it "should expose the origin header" do
+    em {
+      start_server { |ws|
+        ws.onopen { |handshake|
+          handshake.origin.should == 'http://example.com'
+          done
+        }
+      }
+
+      start_client
+    }
+  end
+
+  it "should expose the remote IP address" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          ws.remote_ip.should == "127.0.0.1"
+          done
+        }
+      }
+
+      start_client
+    }
+  end
+
+  it "should send messages successfully" do
+    em {
+      start_server { |ws|
+        ws.onmessage { |message|
+          message.should == "hello server"
+          done
+        }
+      }
+
+      start_client { |client|
+        client.onopen {
+          client.send("hello server")
+        }
+      }
+    }
+  end
+
+  it "should allow connection to be closed with valid close code" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          ws.close(4004, "Bye bye")
+          done
+        }
+      }
+
+      start_client
+      # TODO: Use a real client which understands how to respond to closing
+      # handshakes, sending the handshake currently untested
+    }
+  end
+
+  it "should raise error if if invalid close code is used" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          lambda {
+            ws.close(2000)
+          }.should raise_error("Application code may only use codes from 1000, 3000-4999")
+          done
+        }
+      }
+
+      start_client
+    }
+  end
+
+  it "should call onclose with was_clean set to false if connection closed without closing handshake by server" do
+    em {
+      start_server { |ws|
+        ws.onopen {
+          # Close tcp connection (no close handshake)
+          ws.close_connection
+        }
+        ws.onclose { |event|
+          event.should == {:code => 1006, :was_clean => false}
+          done
+        }
+      }
+      start_client
+    }
+  end
+
+  it "should call onclose with was_clean set to false if connection closed without closing handshake by client" do
+    em {
+      start_server { |ws|
+        ws.onclose { |event|
+          event.should == {:code => 1006, :was_clean => false}
+          done
+        }
+      }
+      start_client { |client|
+        client.onopen {
+          # Close tcp connection (no close handshake)
+          client.close_connection
+        }
+      }
+    }
+  end
+
   it "should call onerror if an application error raised in onopen" do
     em {
       start_server { |ws|
@@ -62,6 +183,41 @@ shared_examples_for "a websocket server" do
     }
   end
 
+  it "should close the connection when a too long frame is sent" do
+    em {
+      start_server { |server|
+        server.max_frame_size = 20
+
+        server.onerror { |e|
+          # 3: Error should be reported to server
+          e.class.should == EventMachine::WebSocket::WSMessageTooBigError
+          e.message.should =~ /Frame length too long/
+        }
+      }
+
+      start_client { |client|
+        client.onopen {
+          EM.next_tick {
+            client.send("This message is longer than 20 characters")
+          }
+
+        }
+
+        client.onmessage { |msg|
+          # 4: This is actually the close message. Really need to use a real
+          # WebSocket client in these tests...
+          done
+        }
+
+        client.onclose {
+          # 4: Drafts 75 & 76 don't send a close message, they just close the
+          # connection
+          done
+        }
+      }
+    }
+  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
@@ -87,5 +243,23 @@ shared_examples_for "a websocket server" do
         start_client { }
       }
     end
+
+    it "should not change the encoding of strings sent to send [antiregression]" do
+      em {
+        start_server { |server|
+          server.onopen {
+            s = "example string"
+            s.force_encoding("UTF-8")
+
+            server.send(s)
+
+            s.encoding.should == Encoding.find("UTF-8")
+            done
+          }
+        }
+
+        start_client { }
+      }
+    end
   end
 end

data/spec/unit/framing_spec.rb

@@ -1,14 +1,23 @@
+# encoding: BINARY
+
 require 'helper'
 
 describe EM::WebSocket::Framing03 do
   class FramingContainer
     include EM::WebSocket::Framing03
     
+    def initialize
+      @connection = Object.new
+      def @connection.max_frame_size
+        1000000
+      end
+    end
+
     def <<(data)
       @data << data
-      process_data(data)
+      process_data
     end
-
+    
     def debug(*args); end
   end
   
@@ -122,9 +131,16 @@ describe EM::WebSocket::Framing04 do
   class FramingContainer04
     include EM::WebSocket::Framing04
 
+    def initialize
+      @connection = Object.new
+      def @connection.max_frame_size
+        1000000
+      end
+    end
+
     def <<(data)
       @data << data
-      process_data(data)
+      process_data
     end
 
     def debug(*args); end
@@ -184,9 +200,16 @@ describe EM::WebSocket::Framing07 do
   class FramingContainer07
     include EM::WebSocket::Framing07
 
+    def initialize
+      @connection = Object.new
+      def @connection.max_frame_size
+        1000000
+      end
+    end
+
     def <<(data)
       @data << data
-      process_data(data)
+      process_data
     end
 
     def debug(*args); end
@@ -199,127 +222,77 @@ describe EM::WebSocket::Framing07 do
 
   # 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
+  describe "examples from the spec" do
+    it "a single-frame unmakedtext message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x81\x05\x48\x65\x6c\x6c\x6f" # "\x84\x05Hello"
+    end
 
-      it "Ping request" do
-        @f.should_receive(:message).with(:ping, '', 'Hello')
-        @f << "\x89\x85\x01\x01\x01\x01Idmmn"
-      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 pong response" do
-        @f.should_receive(:message).with(:pong, '', 'Hello')
-        @f << "\x8a\x85\x01\x01\x01\x01Idmmn"
-      end
+    it "a fragmented unmasked text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x01\x03Hel"
+      @f << "\x80\x02lo"
+    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 "Ping request" do
+      @f.should_receive(:message).with(:ping, '', 'Hello')
+      @f << "\x89\x05Hello"
+    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
+    it "a pong response" do
+      @f.should_receive(:message).with(:pong, '', 'Hello')
+      @f << "\x8a\x05Hello"
     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 "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 "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
+    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 "client side" do
-    before do
-      @f.mask_outbound_messages = true
-      @f.require_masked_inbound_messages = false
+  describe "other tests" do
+    it "should raise a WSProtocolError 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::WSProtocolError, "Unknown opcode 3")
     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
+    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
 
-    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 raise if non-fin frame is followed by a non-continuation data frame (continuation frame would be expected)" do
+      lambda {
+        @f << 0b00000001 # Not fin, text
+        @f << 0b00000001 # Length 1
+        @f << 'f'
+        @f << 0b10000001 # fin, text (continutation expected)
+        @f << 0b00000001 # Length 1
+        @f << 'b'
+      }.should raise_error(EM::WebSocket::WebSocketError, 'Continuation frame expected')
+    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
+    it "should raise on non-fin control frames (control frames must not be fragmented)" do
+      lambda {
+        @f << 0b00001010 # Not fin, pong (opcode 10)
+        @f << 0b00000000 # Length 1
+      }.should raise_error(EM::WebSocket::WebSocketError, 'Control frames must not be fragmented')
     end
   end
 end