faye 0.6.8 → 0.7.0

data/spec/javascript/client_spec.js

@@ -1,6 +1,7 @@
 JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
   before(function() { with(this) {
     this.transport = {connectionType: "fake", send: function() {}}
+    Faye.extend(transport, Faye.Publisher)
     stub(Faye.Transport, "get").yields([transport])
   }})
   
@@ -103,7 +104,7 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
         stubResponse({channel:    "/meta/handshake",
                       successful: true,
                       version:    "1.0",
-                      supportedConnectionTypes: ["websocket"],
+                      supportedConnectionTypes: ["long-polling", "websocket"],
                       clientId:   "fakeid" })
       }})
 
@@ -116,16 +117,26 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
         client.handshake()
         assertEqual( "CONNECTED", client.getState() )
       }})
-
+      
+      it("registers any pre-existing subscriptions", function() { with(this) {
+        expect(client, "subscribe").given([], true)
+        client.handshake()
+      }})
+      
       it("selects a new transport based on what the server supports", function() { with(this) {
-        expect(Faye.Transport, "get").given(instanceOf(Faye.Client), ["websocket"])
+        expect(Faye.Transport, "get").given(instanceOf(Faye.Client), ["long-polling", "websocket"])
                                      .yielding([transport])
         client.handshake()
       }})
-
-      it("registers any pre-existing subscriptions", function() { with(this) {
-        expect(client, "subscribe").given([], true)
-        client.handshake()
+      
+      describe("with websocket disabled", function() { with(this) {
+        before(function() { this.client.disable('websocket') })
+        
+        it("selects a new transport, excluding websocket", function() { with(this) {
+          expect(Faye.Transport, "get").given(instanceOf(Faye.Client), ["long-polling"])
+                                       .yielding([transport])
+          client.handshake()
+        }})
       }})
     }})
 
@@ -264,9 +275,23 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
     }})
     
     it("puts the client in the DISCONNECTED state", function() { with(this) {
+      stub(transport, "close")
       client.disconnect()
       assertEqual( "DISCONNECTED", client.getState() )
     }})
+    
+    describe("on successful response", function() { with(this) {
+      before(function() { with(this) {
+        stubResponse({channel:      "/meta/disconnect",
+                      successful:   true,
+                      clientId:     "fakeid" })
+      }})
+      
+      it("closes the transport", function() { with(this) {
+        expect(transport, "close")
+        client.disconnect()
+      }})
+    }})
   }})
   
   describe("subscribe", function() { with(this) {
@@ -563,6 +588,29 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
       assertThrows(Error, function() { client.publish("/messages/*", {hello: "world"}) })
     }})
     
+    describe("on publish failure", function() { with(this) {
+      before(function() { with(this) {
+        stubResponse({channel:    "/messages/foo",
+                      error:      "407:/messages/foo:Failed to publish",
+                      successful: false,
+                      clientId:   "fakeid" })
+      }})
+      
+      it("should not be published", function() { with(this) {
+        var published = false
+        client.publish("/messages/foo", {text: "hi"}).callback(function() { published = true })
+        assert( !published )
+      }})
+      
+      it("reports the error through an errback", function() { with(this) {
+        var error = null
+        client.publish("/messages/foo", {text: "hi"}).errback(function(e) { error = e })
+        assertEqual( 407, error.code )
+        assertEqual( ["/messages/foo"], error.params )
+        assertEqual( "Failed to publish", error.message )
+      }})
+    }})
+    
     describe("with an outgoing extension installed", function() { with(this) {
       before(function() { with(this) {
         var extension = {
@@ -608,4 +656,48 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
       }})
     }})
   }})
+  
+  describe("network notifications", function() { with(this) {
+    before(function() { this.createClient() })
+    
+    describe("in the default state", function() { with(this) {
+      it("broadcasts a down notification", function() { with(this) {
+        expect(client, "trigger").given("transport:down")
+        transport.trigger("down")
+      }})
+      
+      it("broadcasts an up notification", function() { with(this) {
+        expect(client, "trigger").given("transport:up")
+        transport.trigger("up")
+      }})
+    }})
+    
+    describe("when the transport is up", function() { with(this) {
+      before(function() { this.transport.trigger("up") })
+      
+      it("broadcasts a down notification", function() { with(this) {
+        expect(client, "trigger").given("transport:down")
+        transport.trigger("down")
+      }})
+      
+      it("does not broadcast an up notification", function() { with(this) {
+        expect(client, "trigger").exactly(0)
+        transport.trigger("up")
+      }})
+    }})
+    
+    describe("when the transport is down", function() { with(this) {
+      before(function() { this.transport.trigger("down") })
+      
+      it("does not broadcast a down notification", function() { with(this) {
+        expect(client, "trigger").exactly(0)
+        transport.trigger("down")
+      }})
+      
+      it("broadcasts an up notification", function() { with(this) {
+        expect(client, "trigger").given("transport:up")
+        transport.trigger("up")
+      }})
+    }})
+  }})
 }})

data/spec/javascript/engine_spec.js

@@ -62,6 +62,12 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
     setTimeout(resume, 20)
   },
   
+  publish_by: function(name, message, resume) {
+    message = Faye.extend({clientId: this._clients[name], id: Faye.random()}, message)
+    this.engine.publish(message)
+    setTimeout(resume, 10)
+  },
+  
   ping: function(name, resume) {
     this.engine.ping(this._clients[name])
     resume()
@@ -71,6 +77,24 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
     setTimeout(resume, time)
   },
   
+  expect_event: function(name, event, args, resume) {
+    var params  = [this._clients[name]].concat(args),
+        handler = function() {}
+    
+    this.engine.bind(event, handler)
+    this.expect(handler, "apply").given(undefined, params)
+    resume()
+  },
+  
+  expect_no_event: function(name, event, args, resume) {
+    var params  = [this._clients[name]].concat(args),
+        handler = function() {}
+    
+    this.engine.bind(event, handler)
+    this.expect(handler, "apply").exactly(0)
+    resume()
+  },
+  
   expect_message: function(name, messages, resume) {
     this.assertEqual(messages, this._inboxes[name])
     resume()
@@ -81,6 +105,11 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
     resume()
   },
   
+  check_different_messages: function(a, b, resume) {
+    this.assertNotSame(this._inboxes[a][0], this._inboxes[b][0])
+    resume()
+  },
+  
   clean_redis_db: function(resume) {
     this.engine.disconnect()
     var redis = require('redis').createClient(6379, 'localhost', {no_ready_check: true})
@@ -122,6 +151,11 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
         $R(1,7).forEach(function(i) { create_client("client" + i) })
         check_num_clients(10)
       }})
+      
+      it("publishes an event", function() { with(this) {
+        expect(engine, "trigger").given("handshake", match(/^[a-z0-9]+$/))
+        create_client("dave")
+      }})
     }})
     
     describe("clientExists", function() { with(this) {
@@ -143,11 +177,11 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
       }})
       
       it("prolongs the life of a client", function() { with(this) {
-        clock_tick(330)
+        clock_tick(450)
         ping("alice")
-        clock_tick(330)
+        clock_tick(450)
         check_client_exists("alice", true)
-        clock_tick(330)
+        clock_tick(450)
         check_client_exists("alice", false)
       }})
     }})
@@ -157,6 +191,11 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
         destroy_client("alice")
         check_client_exists("alice", false)
       }})
+      
+      it("publishes an event", function() { with(this) {
+        expect_event("alice", "disconnect", [])
+        destroy_client("alice")
+      }})
 
       describe("when the client has subscriptions", function() { with(this) {
         before(function() { with(this) {
@@ -170,6 +209,46 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
           publish(message)
           expect_no_message("alice")
         }})
+        
+        it("publishes an event", function() { with(this) {
+          expect_event("alice", "disconnect", [])
+          destroy_client("alice")
+        }})
+      }})
+    }})
+    
+    describe("subscribe", function() { with(this) {
+      it("publishes an event", function() { with(this) {
+        expect_event("alice", "subscribe", ["/messages/foo"])
+        subscribe("alice", "/messages/foo")
+      }})
+      
+      describe("when the client is subscribed to the channel", function() { with(this) {
+        before(function() { this.subscribe("alice", "/messages/foo") })
+        
+        it("does not publish an event", function() { with(this) {
+          expect_no_event("alice", "subscribe", ["/messages/foo"])
+          subscribe("alice", "/messages/foo")
+        }})
+      }})
+    }})
+    
+    
+    describe("unsubscribe", function() { with(this) {
+      before(function() { this.subscribe("alice", "/messages/bar") })
+      
+      it("does not publish an event", function() { with(this) {
+        expect_no_event("alice", "unsubscribe", ["/messages/foo"])
+        unsubscribe("alice", "/messages/foo")
+      }})
+      
+      describe("when the client is subscribed to the channel", function() { with(this) {
+        before(function() { this.subscribe("alice", "/messages/foo") })
+        
+        it("publishes an event", function() { with(this) {
+          expect_event("alice", "unsubscribe", ["/messages/foo"])
+          unsubscribe("alice", "/messages/foo")
+        }})
       }})
     }})
     
@@ -188,6 +267,16 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
           expect_no_message("bob")
           expect_no_message("carol")
         }})
+        
+        it("publishes a :publish event with a clientId", function() { with(this) {
+          expect_event("bob", "publish", ["/messages/foo", "ok"])
+          publish_by("bob", message)
+        }})
+        
+        it("publishes a :publish event with no clientId", function() { with(this) {
+          expect_event(null, "publish", ["/messages/foo", "ok"])
+          publish(message)
+        }})
       }})
       
       describe("with a subscriber", function() { with(this) {
@@ -205,6 +294,11 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
           publish(message)
           expect_message("alice", [message])
         }})
+        
+        it("publishes a :publish event with a clientId", function() { with(this) {
+          expect_event("bob", "publish", ["/messages/foo", "ok"])
+          publish_by("bob", message)
+        }})
       }})
       
       describe("with a subscriber that is removed", function() { with(this) {
@@ -219,6 +313,11 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
           expect_no_message("bob")
           expect_no_message("carol")
         }})
+        
+        it("publishes a :publish event with a clientId", function() { with(this) {
+          expect_event("bob", "publish", ["/messages/foo", "ok"])
+          publish_by("bob", message)
+        }})
       }})
       
       describe("with multiple subscribers", function() { with(this) {
@@ -264,6 +363,11 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
           expect_no_message("bob")
           expect_message("carol", [message])
         }})
+        
+        it("delivers a unique copy of the message to each client", function() { with(this) {
+          publish(message)
+          check_different_messages("alice", "carol")
+        }})
       }})
       
       describe("with multiple matching subscriptions for the same client", function() { with(this) {
@@ -332,8 +436,17 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
     after(function() { this.clean_redis_db() })
     
     itShouldBehaveLike("faye engine")
+    
     describe("distribution", function() { with(this) {
       itShouldBehaveLike("distributed engine")
     }})
+    
+    describe("using a Unix socket", function() { with(this) {
+      before(function() { with(this) {
+        this.engineOpts.socket = "/tmp/redis.sock"
+      }})
+      
+      itShouldBehaveLike("faye engine")
+    }})
   }})
 }})

data/spec/javascript/node_adapter_spec.js

@@ -5,13 +5,11 @@ JS.ENV.NodeAdapterSteps = JS.Test.asyncSteps({
   start_server: function(port, resume) {
     this._port = port
     this._app  = new Faye.NodeAdapter(this.options())
-    this._app.listen(port)
-    setTimeout(resume, 50)
+    this._app.listen(port, {}, resume)
   },
   
   stop_server: function(resume) {
-    this._app.stop()
-    resume()
+    this._app.stop(resume)
   },
   
   header: function(key, value, resume) {

data/spec/javascript/server/handshake_spec.js

@@ -90,18 +90,6 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
             }, response)
         })
       }})
-      
-      it("returns a successful response for local clients", function() { with(this) {
-        expect(engine, "createClient").yields(["clientid"])
-        server.handshake(message, true, function(response) {
-          assertEqual({
-              channel:    "/meta/handshake",
-              successful: true,
-              version:    "1.0",
-              clientId:   "clientid"
-            }, response)
-        })
-      }})
     }})
     
     describe("with no matching supportedConnectionTypes", function() { with(this) {

data/spec/javascript/server/integration_spec.js

@@ -1,24 +1,32 @@
 JS.ENV.IntegrationSteps = JS.Test.asyncSteps({
-  server: function(port, callback) {
-    this._adapter = new Faye.NodeAdapter({mount: "/bayeux", timeout: 25})
-    this._adapter.listen(port)
+  server: function(port, ssl, callback) {
+    var shared  = __dirname + '/../../../examples/shared',
+        
+        options = ssl
+                ? { key: shared + '/server.key', cert: shared + '/server.crt' }
+                : null
+    
+    this._adapter = new Faye.NodeAdapter({mount: "/bayeux", timeout: 2})
     this._port = port
-    setTimeout(callback, 100)
+    this._secure = ssl
+    this._adapter.listen(port, options, callback)
   },
   
   stop: function(callback) {
-    this._adapter.stop()
-    setTimeout(callback, 100)
+    for (var id in this._clients) this._clients[id].disconnect()
+    var self = this
+    setTimeout(function() { self._adapter.stop(callback) }, 100)
   },
   
   client: function(name, channels, callback) {
+    var scheme = this._secure ? "https" : "http"
     this._clients = this._clients || {}
     this._inboxes = this._inboxes || {}
-    this._clients[name] = new Faye.Client("http://0.0.0.0:" + this._port  + "/bayeux")
+    this._clients[name] = new Faye.Client(scheme + "://0.0.0.0:" + this._port  + "/bayeux")
     this._inboxes[name] = {}
     
     var n = channels.length
-    if (n === 0) return callback()
+    if (n === 0) return this._clients[name].connect(callback)
     
     Faye.each(channels, function(channel) {
       var subscription = this._clients[name].subscribe(channel, function(message) {
@@ -47,32 +55,69 @@ JS.ENV.IntegrationSteps = JS.Test.asyncSteps({
 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"}])
+  sharedExamplesFor("message bus", function() { with(this) {
+    before(function() { with(this) {
+      server(8000, serverOptions.ssl)
+      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 = "}])
+    }})
   }})
   
-  it("does not deliver messages for unsubscribed channels", function() { with(this) {
-    publish("alice", "/bar", {hello: "world"})
-    check_inbox("bob", "/foo", [])
+  sharedExamplesFor("network transports", function() { with(this) {
+    describe("with HTTP transport", function() { with(this) {
+      before(function() { with(this) {
+        stub(Faye.Transport.WebSocket, "isUsable").yields([false])
+      }})
+      
+      itShouldBehaveLike("message bus")
+    }})
+    
+    describe("with WebSocket transport", function() { with(this) {
+      before(function() { with(this) {
+        stub(Faye.Transport.WebSocket, "isUsable").yields([true])
+      }})
+      
+      itShouldBehaveLike("message bus")
+    }})
   }})
   
-  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"}])
+  describe("with HTTP server", function() { with(this) {
+    before(function() { with(this) {
+      this.serverOptions = {ssl: false}
+    }})
+    
+    itShouldBehaveLike("network transports")
   }})
   
-  it("delivers multibyte strings", function() { with(this) {
-    publish("alice", "/foo", {hello: "Apple = "})
-    check_inbox("bob", "/foo", [{hello: "Apple = "}])
+  describe("with HTTPS server", function() { with(this) {
+    before(function() { with(this) {
+      this.serverOptions = {ssl: true}
+    }})
+    
+    itShouldBehaveLike("network transports")
   }})
 }})
+