faye 0.5.5 → 0.6.0

data/spec/javascript/server/connect_spec.js

@@ -0,0 +1,168 @@
+JS.ENV.Server.ConnectSpec = JS.Test.describe("Server connect", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+  }})
+  
+  describe("#connect", function() { with(this) {
+    before(function() { with(this) {
+      this.clientId = "fakeclientid"
+      this.message = {channel:  "/meta/connect",
+                      clientId: "fakeclientid",
+                      connectionType: "long-polling"}
+    }})
+    
+    describe("with valid parameters", function() { with(this) {
+      before(function() { with(this) {
+        message.advice = {timeout: 60}
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      
+      it("connects to the engine to wait for new messages", function() { with(this) {
+        expect(engine, "connect").given(clientId, {timeout: 60}).yielding([[]])
+        server.connect(message, false, function() {})
+      }})
+      
+      it("returns a successful response and any queued messages", function() { with(this) {
+        stub(engine, "connect").yields([{channel: "/x", data: "hello"}])
+        server.connect(message, false, function(response) {
+          assertEqual([
+            { channel:    "/meta/connect",
+              successful: true,
+              clientId:   clientId
+            },
+            { channel: "/x",
+              data:    "hello"
+            }
+          ], 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, "connect")
+          server.connect(message, false, function(response) {
+            assertEqual({
+                channel:    "/meta/connect",
+                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 connect to the engine", function() { with(this) {
+        expect(engine, "connect").exactly(0)
+        server.connect(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        server.connect(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/connect",
+              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 connect to the engine", function() { with(this) {
+        expect(engine, "connect").exactly(0)
+        server.connect(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        server.connect(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/connect",
+              successful: false,
+              error:      "402:clientId:Missing required parameter"
+            }, response)
+        })
+      }})
+    }})
+    
+    describe("missing connectionType", function() { with(this) {
+      before(function() { with(this) {
+        delete message.connectionType
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      
+      it("does not connect to the engine", function() { with(this) {
+        expect(engine, "connect").exactly(0)
+        server.connect(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        server.connect(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/connect",
+              successful: false,
+              error:      "402:connectionType:Missing required parameter"
+            }, response)
+        })
+      }})
+    }})
+    
+    describe("with an unknown connectionType", function() { with(this) {
+      before(function() { with(this) {
+        message.connectionType = "flash"
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      
+      it("does not connect to the engine", function() { with(this) {
+        expect(engine, "connect").exactly(0)
+        server.connect(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        server.connect(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/connect",
+              successful: false,
+              error:      "301:flash:Connection types not supported"
+            }, 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 connect to the engine", function() { with(this) {
+        expect(engine, "connect").exactly(0)
+        server.connect(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        server.connect(message, false, function(response) {
+          assertEqual({
+              channel:    "/meta/connect",
+              successful: false,
+              error:      "invalid"
+            }, response)
+        })
+      }})
+    }})
+  }})
+}})

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", advice: anything()}], 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", advice: anything(), ext: {auth: "password"}}], response )
+    }})
+  }})
+}})
+

data/spec/javascript/server/handshake_spec.js

@@ -0,0 +1,153 @@
+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()
+  }})
+  
+  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: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket"],
+              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: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket"],
+                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: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket"]
+            }, 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: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket"]
+            }, 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) {
+      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: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket"]
+            }, 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: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket"]
+            }, response)
+        })
+      }})
+    }})
+  }})
+}})