faye 0.6.4 → 0.6.5

data/spec/javascript/engine_spec.js

@@ -195,6 +195,12 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
           subscribe("alice", "/messages/foo")
         }})
         
+        it("delivers multibyte messages correctly", function() { with(this) {
+          message.data = "Apple = "
+          publish(message)
+          expect_message("alice", [message])
+        }})
+        
         it("delivers messages to the subscribed client", function() { with(this) {
           publish(message)
           expect_message("alice", [message])

data/spec/javascript/server/integration_spec.js

@@ -0,0 +1,78 @@
+JS.ENV.IntegrationSteps = JS.Test.asyncSteps({
+  server: function(port, callback) {
+    this._adapter = new Faye.NodeAdapter({mount: "/bayeux", timeout: 25})
+    this._adapter.listen(port)
+    this._port = port
+    setTimeout(callback, 100)
+  },
+  
+  stop: function(callback) {
+    this._adapter.stop()
+    setTimeout(callback, 100)
+  },
+  
+  client: function(name, channels, callback) {
+    this._clients = this._clients || {}
+    this._inboxes = this._inboxes || {}
+    this._clients[name] = new Faye.Client("http://0.0.0.0:" + this._port  + "/bayeux")
+    this._inboxes[name] = {}
+    
+    var n = channels.length
+    if (n === 0) return callback()
+    
+    Faye.each(channels, function(channel) {
+      var subscription = this._clients[name].subscribe(channel, function(message) {
+        this._inboxes[name][channel] = this._inboxes[name][channel] || []
+        this._inboxes[name][channel].push(message)
+      }, this)
+      subscription.callback(function() {
+        n -= 1
+        if (n === 0) callback()
+      })
+    }, this)
+  },
+  
+  publish: function(name, channel, message, callback) {
+    this._clients[name].publish(channel, message)
+    setTimeout(callback, 100)
+  },
+  
+  check_inbox: function(name, channel, messages, callback) {
+    var inbox = this._inboxes[name][channel] || []
+    this.assertEqual(messages, inbox)
+    callback()
+  }
+})
+
+JS.ENV.Server.IntegrationSpec = JS.Test.describe("Server integration", function() { with(this) {
+  include(IntegrationSteps)
+  
+  before(function() { with(this) {
+    server(8000)
+    client("alice", [])
+    client("bob", ["/foo"])
+  }})
+  
+  after(function() { this.stop() })
+  
+  it("delivers a message between clients", function() { with(this) {
+    publish("alice", "/foo", {hello: "world"})
+    check_inbox("bob", "/foo", [{hello: "world"}])
+  }})
+  
+  it("does not deliver messages for unsubscribed channels", function() { with(this) {
+    publish("alice", "/bar", {hello: "world"})
+    check_inbox("bob", "/foo", [])
+  }})
+  
+  it("delivers multiple messages", function() { with(this) {
+    publish("alice", "/foo", {hello: "world"})
+    publish("alice", "/foo", {hello: "world"})
+    check_inbox("bob", "/foo", [{hello: "world"},{hello: "world"}])
+  }})
+  
+  it("delivers multibyte strings", function() { with(this) {
+    publish("alice", "/foo", {hello: "Apple = "})
+    check_inbox("bob", "/foo", [{hello: "Apple = "}])
+  }})
+}})

data/spec/javascript/web_socket/draft75parser_spec.js

@@ -0,0 +1,39 @@
+JS.ENV.WebSocket = JS.ENV.WebSocket || {}
+
+JS.ENV.WebSocket.Draft75ParserSpec = JS.Test.describe("WebSocket.Draft75Parser", function() { with(this) {
+  before(function() { with(this) {
+    this.webSocket = {dispatchEvent: function() {}}
+    this.socket = new FakeSocket
+    this.parser = new Faye.WebSocket.Draft75Parser(webSocket, socket)
+  }})
+  
+  describe("parse", function() { with(this) {
+    it("parses text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Hello")
+      parser.parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+    }})
+    
+    it("parses multibyte text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Apple = ")
+      parser.parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
+    }})
+    
+    it("parses fragmented frames", function() { with(this) {
+      expect(webSocket, "receive").given("Hello")
+      parser.parse([0x00, 0x48, 0x65, 0x6c])
+      parser.parse([0x6c, 0x6f, 0xff])
+    }})
+  }})
+  
+  describe("frame", function() { with(this) {
+    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
+      parser.frame("Hello")
+      assertEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], socket.read() )
+    }})
+    
+    it("encodes multibyte characters correctly", function() { with(this) {
+      parser.frame("Apple = ")
+      assertEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], socket.read() )
+    }})
+  }})
+}})

data/spec/javascript/web_socket/protocol8parser_spec.js

@@ -0,0 +1,130 @@
+JS.ENV.WebSocket = JS.ENV.WebSocket || {}
+
+JS.ENV.WebSocket.Protocol8ParserSpec = JS.Test.describe("WebSocket.Protocol8Parser", function() { with(this) {
+  before(function() { with(this) {
+    this.webSocket = {dispatchEvent: function() {}}
+    this.socket = new FakeSocket
+    this.parser = new Faye.WebSocket.Protocol8Parser(webSocket, socket)
+  }})
+  
+  define("parse", function() {
+    var bytes = [];
+    for (var i = 0, n = arguments.length; i < n; i++) bytes = bytes.concat(arguments[i])
+    this.parser.parse(new Buffer(bytes))
+  })
+  
+  describe("parse", function() { with(this) {
+    define("mask", function() {
+      return this._mask = this._mask || Faye.map([1,2,3,4], function() { return Math.floor(Math.random() * 255) })
+    })
+    
+    define("maskMessage", function(bytes) {
+      var output = []
+      Array.prototype.forEach.call(bytes, function(b, i) {
+        output[i] = bytes[i] ^ this.mask()[i % 4]
+      }, this)
+      return output
+    })
+    
+    it("parses unmasked text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Hello")
+      parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+    }})
+    
+    it("parses fragmented text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Hello")
+      parse([0x01, 0x03, 0x48, 0x65, 0x6c])
+      parse([0x80, 0x02, 0x6c, 0x6f])
+    }})
+    
+    it("parses masked text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Hello")
+      parse([0x81, 0x85], mask(), maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
+    }})
+    
+    it("parses masked fragmented text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Hello")
+      parse([0x01, 0x81], mask(), maskMessage([0x48]))
+      parse([0x80, 0x84], mask(), maskMessage([0x65, 0x6c, 0x6c, 0x6f]))
+    }})
+    
+    it("closes the socket if the frame has an unrecognized opcode", function() { with(this) {
+      expect(webSocket, "close").given("protocol_error")
+      parse([0x83, 0x00])
+    }})
+    
+    it("parses unmasked multibyte text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Apple = ")
+      parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
+    }})
+    
+    it("parses fragmented multibyte text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Apple = ")
+      parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])
+      parse([0x80, 0x01, 0xbf])
+    }})
+    
+    it("parses masked multibyte text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Apple = ")
+      parse([0x81, 0x8b], mask(), maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]))
+    }})
+    
+    it("parses masked fragmented multibyte text frames", function() { with(this) {
+      expect(webSocket, "receive").given("Apple = ")
+      parse([0x01, 0x8a], mask(), maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]))
+      parse([0x80, 0x81], mask(), maskMessage([0xbf]))
+    }})
+    
+    it("parses unmasked medium-length text frames", function() { with(this) {
+      expect(webSocket, "receive").given("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
+      parse([129, 126, 0, 200, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111])
+    }})
+    
+    it("parses masked medium-length text frames", function() { with(this) {
+      expect(webSocket, "receive").given("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
+      parse([129, 254, 0, 200], mask(), maskMessage([72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111]))
+    }})
+    
+    it("replies to pings with a pong", function() { with(this) {
+      expect(webSocket, "send").given("OHAI", "pong")
+      parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
+    }})
+  }})
+  
+  describe("frame", function() { with(this) {
+    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
+      parser.frame("Hello")
+      assertEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], socket.read() )
+    }})
+    
+    it("encodes multibyte characters correctly", function() { with(this) {
+      parser.frame("Apple = ")
+      assertEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], socket.read() )
+    }})
+    
+    it("encodes medium-length strings using extra length bytes", function() { with(this) {
+      parser.frame("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
+      assertEqual( [129, 126, 0, 200, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111], socket.read() )
+    }})
+    
+    it("encodes long strings using extra length bytes", function() { with(this) {
+      var reps = 13108, message = '', output = [0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04]
+      while (reps--) {
+        message += "Hello"
+        output = output.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
+      }
+      parser.frame(message)
+      assertEqual( output, socket.read() )
+    }})
+    
+    it("encodes close frames with an error code", function() { with(this) {
+      parser.frame("Hello", "close", "protocol_error")
+      assertEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], socket.read() )
+    }})
+    
+    it("encodes pong frames", function() { with(this) {
+      parser.frame("", "pong")
+      assertEqual( [0x8a, 0x00], socket.read() )
+    }})
+  }})
+}})

data/spec/node.js

@@ -6,6 +6,21 @@ JS.Packages(function() { with(this) {
   autoload(/.*Spec/, {from: 'spec/javascript'})
 }})
 
+FakeSocket = function() {
+  this._fragments = []
+}
+FakeSocket.prototype.write = function(buffer, encoding) {
+  this._fragments.push([buffer, encoding])
+}
+FakeSocket.prototype.read = function() {
+  var output = []
+  this._fragments.forEach(function(buffer, i) {
+    for (var j = 0, n = buffer[0].length; j < n; j++)
+    output.push(buffer[0][j])
+  })
+  return output
+}
+
 JS.require('Faye', 'JS.Test', 'JS.Range', function() {
   JS.Test.Unit.Assertions.include({
     assertYield: function(expected) {
@@ -27,6 +42,9 @@ JS.require('Faye', 'JS.Test', 'JS.Range', function() {
               'Server.SubscribeSpec',
               'Server.UnsubscribeSpec',
               'Server.ExtensionsSpec',
+              'Server.IntegrationSpec',
+              'WebSocket.Draft75ParserSpec',
+              'WebSocket.Protocol8ParserSpec',
               'NodeAdapterSpec',
               'ClientSpec',
               'TransportSpec',

data/spec/ruby/engine_spec.rb

@@ -1,3 +1,5 @@
+# encoding=utf-8
+
 require "spec_helper"
 
 EngineSteps = EM::RSpec.async_steps do
@@ -94,6 +96,7 @@ describe "Pub/sub engines" do
   end
   
   shared_examples_for "faye engine" do
+    include EncodingHelper
     include EngineSteps
     
     let(:options) { {:timeout => 1} }
@@ -189,6 +192,12 @@ describe "Pub/sub engines" do
           publish @message
           expect_message :alice, [@message]
         end
+        
+        it "delivers multibyte messages correctly" do
+          @message["data"] = encode "Apple = "
+          publish @message
+          expect_message :alice, [@message]
+        end
       end
       
       describe "with a subscriber that is removed" do

data/spec/ruby/server/integration_spec.rb

@@ -0,0 +1,88 @@
+# encoding=utf-8
+
+require "spec_helper"
+
+require "thin"
+Thin::Logging.silent = true
+
+IntegrationSteps = EM::RSpec.async_steps do
+  def server(port, &callback)
+    @adapter = Faye::RackAdapter.new(:mount => "/bayeux", :timeout => 25)
+    @adapter.listen(port)
+    @port = port
+    EM.next_tick(&callback)
+  end
+  
+  def stop(&callback)
+    @adapter.stop
+    EM.next_tick(&callback)
+  end
+  
+  def client(name, channels, &callback)
+    @clients ||= {}
+    @inboxes ||= {}
+    @clients[name] = Faye::Client.new("http://0.0.0.0:#{@port}/bayeux")
+    @inboxes[name] = {}
+    
+    n = channels.size
+    return callback.call if n.zero?
+    
+    channels.each do |channel|
+      subscription = @clients[name].subscribe(channel) do |message|
+        @inboxes[name][channel] ||= []
+        @inboxes[name][channel] << message
+      end
+      subscription.callback do
+        n -= 1
+        callback.call if n.zero?
+      end
+    end
+  end
+  
+  def publish(name, channel, message, &callback)
+    @clients[name].publish(channel, message)
+    EM.add_timer(0.1, &callback)
+  end
+  
+  def check_inbox(name, channel, messages, &callback)
+    inbox = @inboxes[name][channel] || []
+    inbox.should == messages
+    callback.call
+  end
+end
+
+describe "server integration" do
+  include IntegrationSteps
+  include EncodingHelper
+  
+  before do
+    Faye.ensure_reactor_running!
+    server 8000
+    client :alice, []
+    client :bob,   ["/foo"]
+    sync
+  end
+  
+  after { stop }
+  
+  it "delivers a message between clients" do
+    publish :alice, "/foo", {"hello" => "world"}
+    check_inbox :bob, "/foo", [{"hello" => "world"}]
+  end
+  
+  it "does not deliver messages for unsubscribed channels" do
+    publish :alice, "/bar", {"hello" => "world"}
+    check_inbox :bob, "/foo", []
+  end
+  
+  it "delivers multiple messages" do
+    publish :alice, "/foo", {"hello" => "world"}
+    publish :alice, "/foo", {"hello" => "world"}
+    check_inbox :bob, "/foo", [{"hello" => "world"}, {"hello" => "world"}]
+  end
+  
+  it "delivers multibyte strings" do
+    publish :alice, "/foo", {"hello" => encode("Apple = ")}
+    check_inbox :bob, "/foo", [{"hello" => encode("Apple = ")}]
+  end
+end

data/spec/ruby/web_socket/draft75_parser_spec.rb

@@ -0,0 +1,41 @@
+# encoding=utf-8
+
+require "spec_helper"
+
+describe Faye::WebSocket::Draft75Parser do
+  include EncodingHelper
+  
+  before do
+    @web_socket = mock Faye::WebSocket
+    @parser = Faye::WebSocket::Draft75Parser.new(@web_socket)
+  end
+  
+  describe :parse do
+    it "parses text frames" do
+      @web_socket.should_receive(:receive).with("Hello")
+      parse [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+    end
+    
+    it "parses multibyte text frames" do
+      @web_socket.should_receive(:receive).with(encode "Apple = ")
+      parse [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
+    end
+    
+    it "parses fragmented frames" do
+      @web_socket.should_receive(:receive).with("Hello")
+      parse [0x00, 0x48, 0x65, 0x6c]
+      parse [0x6c, 0x6f, 0xff]
+    end
+  end
+  
+  describe :frame do
+    it "returns the given string formatted as a WebSocket frame" do
+      bytes(@parser.frame "Hello").should == [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+    end
+    
+    it "encodes multibyte characters correctly" do
+      message = encode "Apple = "
+      bytes(@parser.frame message).should == [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
+    end
+  end
+end