face-faye 0.8.9

data/spec/javascript/server/disconnect_spec.js

@@ -0,0 +1,121 @@
+JS.ENV.Server.DisconnectSpec = JS.Test.describe("Server disconnect", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+  }})
+
+  describe("#disconnect", function() { with(this) {
+    before(function() { with(this) {
+      this.clientId = "fakeclientid"
+      this.message = {channel: "/meta/disconnect",
+                      clientId: "fakeclientid"}
+    }})
+
+    describe("with valid parameters", function() { with(this) {
+      before(function() { with(this) {
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+
+      it("destroys the client", function() { with(this) {
+        expect(engine, "destroyClient").given(clientId)
+        server.disconnect(message, false, function() {})
+      }})
+
+      it("returns a successful response", function() { with(this) {
+        stub(engine, "destroyClient")
+        server.disconnect(message, false, function(response) {
+          assertEqual({
+              channel:   "/meta/disconnect",
+              successful: true,
+              clientId:   clientId
+            }, response)
+        })
+      }})
+
+      describe("with a message id", function() { with(this) {
+        before(function() { this.message.id = "foo" })
+
+        it("returns the same id", function() { with(this) {
+          stub(engine, "destroyClient")
+          server.disconnect(message, false, function(response) {
+            assertEqual({
+              channel:    "/meta/disconnect",
+              successful: true,
+              clientId:   clientId,
+              id:         "foo"
+              }, response)
+          })
+        }})
+      }})
+    }})
+
+    describe("with an unknown client", function() { with(this) {
+      before(function() { with(this) {
+        expect(engine, "clientExists").given(clientId).yielding([false])
+      }})
+
+      it("does not destroy the client", function() { with(this) {
+        expect(engine, "destroyClient").exactly(0)
+        server.disconnect(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "destroyClient")
+        server.disconnect(message, false, function(response) {
+          assertEqual({
+              channel:   "/meta/disconnect",
+              successful: false,
+              error:      "401:fakeclientid:Unknown client"
+            }, response)
+        })
+      }})
+    }})
+
+    describe("missing clientId", function() { with(this) {
+      before(function() { with(this) {
+        delete message.clientId
+        expect(engine, "clientExists").given(undefined).yielding([false])
+      }})
+
+      it("does not destroy the client", function() { with(this) {
+        expect(engine, "destroyClient").exactly(0)
+        server.disconnect(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "destroyClient")
+        server.disconnect(message, false, function(response) {
+          assertEqual({
+              channel:   "/meta/disconnect",
+              successful: false,
+              error:      "402:clientId:Missing required parameter"
+            }, response)
+        })
+      }})
+    }})
+
+    describe("with an error", function() { with(this) {
+      before(function() { with(this) {
+        message.error = "invalid"
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+
+      it("does not destroy the client", function() { with(this) {
+        expect(engine, "destroyClient").exactly(0)
+        server.disconnect(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "destroyClient")
+        server.disconnect(message, false, function(response) {
+          assertEqual({
+              channel:   "/meta/disconnect",
+              successful: false,
+              error:      "invalid"
+            }, response)
+        })
+      }})
+    }})
+  }})
+}})

data/spec/javascript/server/extensions_spec.js

@@ -0,0 +1,60 @@
+JS.ENV.Server.ExtensionsSpec = JS.Test.describe("Server extensions", function() { with(this) {
+    before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+  }})
+
+  describe("with an incoming extension installed", function() { with(this) {
+    before(function() { with(this) {
+      var extension = {
+        incoming: function(message, callback) {
+          message.ext = {auth: "password"}
+          callback(message)
+        }
+      }
+      server.addExtension(extension)
+      this.message = {channel: "/foo", data: "hello"}
+    }})
+
+    it("passes incoming messages through the extension", function() { with(this) {
+      expect(engine, "publish").given({channel: "/foo", data: "hello", ext: {auth: "password"}})
+      server.process(message, false, function() {})
+    }})
+
+    it("does not pass outgoing messages through the extension", function() { with(this) {
+      stub(server, "handshake").yields([message])
+      stub(engine, "publish")
+      var response = null
+      server.process({channel: "/meta/handshake"}, false, function(r) { response = r })
+      assertEqual( [{channel: "/foo", data: "hello"}], response )
+    }})
+  }})
+
+  describe("with an outgoing extension installed", function() { with(this) {
+    before(function() { with(this) {
+      var extension = {
+        outgoing: function(message, callback) {
+          message.ext = {auth: "password"}
+          callback(message)
+        }
+      }
+      server.addExtension(extension)
+      this.message = {channel: "/foo", data: "hello"}
+    }})
+
+    it("does not pass incoming messages through the extension", function() { with(this) {
+      expect(engine, "publish").given({channel: "/foo", data: "hello"})
+      server.process(message, false, function() {})
+    }})
+
+    it("passes outgoing messages through the extension", function() { with(this) {
+      stub(server, "handshake").yields([message])
+      stub(engine, "publish")
+      var response = null
+      server.process({channel: "/meta/handshake"}, false, function(r) { response = r })
+      assertEqual( [{channel: "/foo", data: "hello", ext: {auth: "password"}}], response )
+    }})
+  }})
+}})
+

data/spec/javascript/server/handshake_spec.js

@@ -0,0 +1,145 @@
+JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+
+    this.connectionTypes = ["long-polling", "cross-origin-long-polling",
+                            "callback-polling","websocket",
+                            "eventsource","in-process"]
+  }})
+
+  describe("#handshake", function() { with(this) {
+    before(function() { with(this) {
+      this.message = {channel: "/meta/handshake",
+                      version: "1.0",
+                      supportedConnectionTypes: ["long-polling"]}
+    }})
+
+    describe("with valid parameters", function() { with(this) {
+      it("creates a client", function() { with(this) {
+        expect(engine, "createClient")
+        server.handshake(message, false, function() {})
+      }})
+
+      it("returns a successful response", function() { with(this) {
+        stub(engine, "createClient").yields(["clientid"])
+        server.handshake(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/handshake",
+              successful: true,
+              version:    "1.0",
+              supportedConnectionTypes: connectionTypes,
+              clientId:   "clientid"
+            }, response)
+        })
+      }})
+
+      describe("with a message id", function() { with(this) {
+        before(function() { this.message.id = "foo" })
+
+        it("returns the same id", function() { with(this) {
+          stub(engine, "createClient").yields(["clientid"])
+          server.handshake(message, false, function(response) {
+            assertEqual({
+                channel:    "/meta/handshake",
+                successful: true,
+                version:    "1.0",
+                supportedConnectionTypes: connectionTypes,
+                clientId:   "clientid",
+                id:         "foo"
+              }, response)
+          })
+        }})
+      }})
+    }})
+
+    describe("missing version", function() { with(this) {
+      before(function() { delete this.message.version })
+
+      it("does not create a client", function() { with(this) {
+        expect(engine, "createClient").exactly(0)
+        server.handshake(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        server.handshake(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/handshake",
+              successful: false,
+              error:      "402:version:Missing required parameter",
+              version:    "1.0",
+              supportedConnectionTypes: connectionTypes
+            }, response)
+        })
+      }})
+    }})
+
+    describe("missing supportedConnectionTypes", function() { with(this) {
+      before(function() { delete this.message.supportedConnectionTypes })
+
+      it("does not create a client", function() { with(this) {
+        expect(engine, "createClient").exactly(0)
+        server.handshake(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        server.handshake(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/handshake",
+              successful: false,
+              error:      "402:supportedConnectionTypes:Missing required parameter",
+              version:    "1.0",
+              supportedConnectionTypes: connectionTypes
+            }, response)
+        })
+      }})
+    }})
+
+    describe("with no matching supportedConnectionTypes", function() { with(this) {
+      before(function() { with(this) {
+        message.supportedConnectionTypes = ["iframe", "flash"]
+      }})
+
+      it("does not create a client", function() { with(this) {
+        expect(engine, "createClient").exactly(0)
+        server.handshake(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        server.handshake(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/handshake",
+              successful: false,
+              error:      "301:iframe,flash:Connection types not supported",
+              version:    "1.0",
+              supportedConnectionTypes: connectionTypes
+            }, response)
+        })
+      }})
+    }})
+
+    describe("with an error", function() { with(this) {
+      before(function() { with(this) {
+        message.error = "invalid"
+      }})
+
+      it("does not create a client", function() { with(this) {
+        expect(engine, "createClient").exactly(0)
+        server.handshake(message, false, function() {})
+      }})
+
+      it("returns an unsuccessful response", function() { with(this) {
+        server.handshake(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/handshake",
+              successful: false,
+              error:      "invalid",
+              version:    "1.0",
+              supportedConnectionTypes: connectionTypes
+            }, response)
+        })
+      }})
+    }})
+  }})
+}})

data/spec/javascript/server/integration_spec.js

@@ -0,0 +1,131 @@
+JS.ENV.IntegrationSteps = JS.Test.asyncSteps({
+  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._adapter.addExtension({
+      outgoing: function(message, callback) {
+        if (message.data) message.data.tagged = true
+        callback(message)
+      }
+    })
+
+    this._port = port
+    this._secure = ssl
+    this._adapter.listen(port, options, callback)
+  },
+
+  stop: function(callback) {
+    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(scheme + "://0.0.0.0:" + this._port  + "/bayeux")
+    this._inboxes[name] = {}
+
+    var n = channels.length
+    if (n === 0) return this._clients[name].connect(callback)
+
+    for (var i = 0; i < n; i++)
+      (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()
+        })
+      }).call(this, channels[i]);
+  },
+
+  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)
+
+  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", extra: null})
+      check_inbox("bob", "/foo", [{hello: "world", extra: null, tagged: true}])
+    }})
+
+    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", tagged: true}, {hello: "world", tagged: true}])
+    }})
+
+    it("delivers multibyte strings", function() { with(this) {
+      publish("alice", "/foo", {hello: "Apple = "})
+      check_inbox("bob", "/foo", [{hello: "Apple = ", tagged: true}])
+    }})
+  }})
+
+  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")
+    }})
+  }})
+
+  describe("with HTTP server", function() { with(this) {
+    before(function() { with(this) {
+      this.serverOptions = {ssl: false}
+    }})
+
+    itShouldBehaveLike("network transports")
+  }})
+
+  describe("with HTTPS server", function() { with(this) {
+    before(function() { with(this) {
+      this.serverOptions = {ssl: true}
+    }})
+
+    itShouldBehaveLike("network transports")
+  }})
+}})
+