faye 0.8.11 → 1.0.0

data/spec/javascript/server/disconnect_spec.js

@@ -1,121 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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")
-  }})
-}})
-