bushido-faye 0.8.1

data/spec/javascript/node_adapter_spec.js

@@ -0,0 +1,307 @@
+var http = require("http"),
+    querystring = require("querystring")
+
+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, {}, resume)
+  },
+  
+  stop_server: function(resume) {
+    this._app.stop(resume)
+  },
+  
+  header: function(key, value, resume) {
+    this._headers = this._headers || {}
+    this._headers[key] = value
+    resume()
+  },
+  
+  get: function(path, params, resume) {
+    var client  = http.createClient(this._port, "localhost"),
+        body    = querystring.stringify(params),
+        request = client.request("GET", path + (body ? "?" + body : "")),
+        self    = this
+    
+    request.addListener("response", function(response) {
+      self._response = response
+      var data = ""
+      response.addListener("data", function(c) { data += c })
+      response.addListener("end", function() {
+        self._responseBody = data
+        resume()
+      })
+    })
+    request.end()
+  },
+  
+  post: function(path, body, resume) {
+    var client  = http.createClient(this._port, "localhost"),
+        
+        body    = (typeof body === "string")
+                ? body
+                : querystring.stringify(body),
+        
+        headers = Faye.extend({
+          "Host":           "localhost",
+          "Content-Length": body.length
+        }, this._headers || {}),
+        
+        request = client.request("POST", path, headers),
+        self    = this
+    
+    request.addListener("response", function(response) {
+      self._response = response
+      var data = ""
+      response.addListener("data", function(c) { data += c })
+      response.addListener("end", function() {
+        self._responseBody = data
+        resume()
+      })
+    })
+    request.write(body)
+    request.end()
+  },
+  
+  check_status: function(code, resume) {
+    this.assertEqual(code, this._response.statusCode)
+    resume()
+  },
+  
+  check_access_control_origin: function(origin, resume) {
+    this.assertEqual(origin, this._response.headers["access-control-allow-origin"])
+    resume()
+  },
+  
+  check_cache_control: function(value, resume) {
+    this.assertEqual(value, this._response.headers["cache-control"])
+    resume()
+  },
+  
+  check_content_type: function(type, resume) {
+    this.assertEqual(type, this._response.headers["content-type"])
+    resume()
+  },
+  
+  check_content_length: function(length, resume) {
+    this.assertEqual(length, this._response.headers["content-length"])
+    resume()
+  },
+  
+  check_body: function(body, resume) {
+    if (typeof body === "string")
+      this.assertEqual(body, this._responseBody)
+    else
+      this.assertMatch(body, this._responseBody)
+    resume()
+  },
+  
+  check_json: function(object, resume) {
+    this.assertEqual(object, JSON.parse(this._responseBody))
+    resume()
+  }
+})
+
+JS.ENV.NodeAdapterSpec = JS.Test.describe("NodeAdapter", function() { with(this) {
+  include(NodeAdapterSteps)
+  
+  define("options", function() {
+    return {mount: "/bayeux", timeout: 30}
+  })
+  
+  before(function() { with(this) {
+    this.server = {}
+    expect(Faye, "Server").given(options()).returning(server)
+    start_server(8282)
+  }})
+  
+  after(function() { this.stop_server() })
+  
+  describe("POST requests", function() { with(this) {
+    describe("with cross-origin access control", function() { with(this) {
+      sharedBehavior("cross-origin request", function() { with(this) {
+        before(function() { with(this) {
+          header("Origin", "http://example.com")
+        }})
+        
+        it("returns a matching cross-origin access control header", function() { with(this) {
+          stub(server, "process").yields([[]])
+          post("/bayeux", {message: "[]"})
+          check_access_control_origin("http://example.com")
+        }})
+        
+        it("forwards the message param onto the server", function() { with(this) {
+          expect(server, "process").given({channel: "/plain"}, false).yielding([[]])
+          post("/bayeux", "message=%7B%22channel%22%3A%22%2Fplain%22%7D")
+        }})
+        
+        it("returns the server's response as JSON", function() { with(this) {
+          stub(server, "process").yields([[{channel: "/meta/handshake"}]])
+          post("/bayeux", "message=%5B%5D")
+          check_status(200)
+          check_content_type("application/json")
+          check_content_length("31")
+          check_json([{channel: "/meta/handshake"}])
+        }})
+        
+        it("returns a 400 response if malformed JSON is given", function() { with(this) {
+          expect(server, "process").exactly(0)
+          post("/bayeux", "message=%7B%5B")
+          check_status(400)
+          check_content_type("text/plain")
+        }})
+      }})
+      
+      describe("with text/plain", function() { with(this) {
+        before(function() { this.header("Content-Type", "text/plain") })
+        behavesLike("cross-origin request")
+      }})
+      
+      describe("with application/xml", function() { with(this) {
+        before(function() { this.header("Content-Type", "application/xml") })
+        behavesLike("cross-origin request")
+      }})
+    }})
+    
+    describe("with application/json", function() { with(this) {
+      before(function() { with(this) {
+        header("Content-Type", "application/json")
+      }})
+      
+      it("does not return an access control header", function() { with(this) {
+        stub(server, "process").yields([[]])
+        post("/bayeux", "[]")
+        check_access_control_origin(undefined)
+      }})
+      
+      it("forwards the POST body onto the server", function() { with(this) {
+        expect(server, "process").given({channel: "/foo"}, false).yielding([[]])
+        post("/bayeux", '{"channel":"/foo"}')
+      }})
+      
+      it("returns the server's response as JSON", function() { with(this) {
+        stub(server, "process").yields([[{channel: "/meta/handshake"}]])
+        post("/bayeux", "[]")
+        check_status(200)
+        check_content_type("application/json")
+        check_content_length("31")
+        check_json([{channel: "/meta/handshake"}])
+      }})
+      
+      it("returns a 400 response if malformed JSON is given", function() { with(this) {
+        expect(server, "process").exactly(0)
+        post("/bayeux", "[}")
+        check_status(400)
+        check_content_type("text/plain")
+      }})
+    }})
+    
+    describe("with no content type", function() { with(this) {
+      it("forwards the message param onto the server", function() { with(this) {
+        expect(server, "process").given({channel: "/foo"}, false).yielding([[]])
+        post("/bayeux", {message: '{"channel":"/foo"}'})
+      }})
+      
+      it("returns the server's response as JSON", function() { with(this) {
+        stub(server, "process").yields([[{channel: "/meta/handshake"}]])
+        post("/bayeux", {message: "[]"})
+        check_status(200)
+        check_content_type("application/json")
+        check_content_length("31")
+        check_json([{channel: "/meta/handshake"}])
+      }})
+      
+      it("returns a 400 response if malformed JSON is given", function() { with(this) {
+        expect(server, "process").exactly(0)
+        post("/bayeux", {message: "[}"})
+        check_status(400)
+        check_content_type("text/plain")
+      }})
+    }})
+  }})
+  
+  describe("GET requests", function() { with(this) {
+    before(function() { with(this) {
+      this.params = {message: '{"channel":"/foo"}', jsonp: "callback"}
+    }})
+    
+    describe("with valid params", function() { with(this) {
+      before(function() { with(this) {
+        expect(server, "flushConnection").given({channel: "/foo"})
+      }})
+      
+      it("forwards the message param onto the server", function() { with(this) {
+        expect(server, "process").given({channel: "/foo"}, false).yielding([[]])
+        get("/bayeux", params)
+      }})
+      
+      it("returns the server's response as JavaScript", function() { with(this) {
+        stub(server, "process").yields([[{channel: "/meta/handshake"}]])
+        get("/bayeux", params)
+        check_status(200)
+        check_content_type("text/javascript")
+        check_content_length("42")
+        check_body('callback([{"channel":"/meta/handshake"}]);')
+      }})
+      
+      it("does not let the client cache the response", function() { with(this) {
+        stub(server, "process").yields([[{channel: "/meta/handshake"}]])
+        get("/bayeux", params)
+        check_cache_control("no-cache, no-store")
+      }})
+    }})
+    
+    describe("missing jsonp", function() { with(this) {
+      before(function() { with(this) {
+        delete params.jsonp
+        expect(server, "flushConnection")
+      }})
+      
+      it("returns the server's response using the default callback", function() { with(this) {
+        stub(server, "process").yields([[{channel: "/meta/handshake"}]])
+        get("/bayeux", params)
+        check_status(200)
+        check_content_type("text/javascript")
+        check_content_length("47")
+        check_body('jsonpcallback([{"channel":"/meta/handshake"}]);')
+      }})
+    }})
+    
+    sharedBehavior("bad GET request", function() { with(this) {
+      it("does not call the server", function() { with(this) {
+        expect(server, "process").exactly(0)
+        get("/bayeux", params)
+      }})
+      
+      it("returns a 400 response", function() { with(this) {
+        get("/bayeux", params)
+        check_status(400)
+        check_content_type("text/plain")
+      }})
+    }})
+    
+    describe("with malformed JSON", function() { with(this) {
+      before(function() { with(this) {
+        params.message = "[}"
+      }})
+      behavesLike("bad GET request")
+    }})
+    
+    describe("missing message", function() { with(this) {
+      before(function() { with(this) {
+        delete params.message
+      }})
+      behavesLike("bad GET request")
+    }})
+    
+    describe("for the client script", function() { with(this) {
+      it("returns the client script", function() { with(this) {
+        get("/bayeux.js", {})
+        check_status(200)
+        check_content_type("text/javascript")
+        check_body(/function\(\)\{/)
+      }})
+    }})
+  }})
+}})

data/spec/javascript/publisher_spec.js

@@ -0,0 +1,27 @@
+JS.ENV.PublisherSpec = JS.Test.describe("Publisher", function() { with(this) {
+  before(function() { with(this) {
+    this.publisher = Faye.extend({}, Faye.Publisher)
+  }})
+  
+  describe("with subscribers that remove themselves", function() { with(this) {
+    before(function() { with(this) {
+      this.calledA = false
+      this.calledB = false
+      
+      this.handler = function() {
+        calledA = true
+        publisher.unbind("event", handler)
+      }
+      
+      publisher.bind("event", handler)
+      publisher.bind("event", function() { calledB = true })
+    }})
+    
+    it("successfully calls all the callbacks", function() { with(this) {
+      publisher.trigger("event")
+      assert( calledA )
+      assert( calledB )
+    }})
+  }})
+}})
+

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)
+        })
+      }})
+    }})
+  }})
+}})