faye 0.5.5 → 0.6.0

data/spec/javascript/engine_spec.js

@@ -0,0 +1,319 @@
+JS.ENV.EngineSteps = JS.Test.asyncSteps({
+  create_client: function(name, resume) {
+    var inboxes = this._inboxes = this._inboxes || {}
+    var clients = this._clients = this._clients || {}
+    this.engine.createClient(function(clientId) {
+      clients[name] = clientId
+      inboxes[name] = inboxes[name] || []
+      resume()
+    })
+  },
+  
+  connect: function(name, engine, resume) {
+    var clientId = this._clients[name]
+    var inboxes  = this._inboxes
+    engine.connect(clientId, {}, function(m) {
+      Faye.each(m, function(message) {
+        delete message.id
+        inboxes[name].push(message)
+      })
+    })
+    setTimeout(resume, 10)
+  },
+  
+  destroy_client: function(name, resume) {
+    this.engine.destroyClient(this._clients[name], resume)
+  },
+  
+  check_client_id: function(name, pattern, resume) {
+    this.assertMatch(pattern, this._clients[name])
+    resume()
+  },
+  
+  check_num_clients: function(n, resume) {
+    var ids = new JS.Set()
+    Faye.each(this._clients, function(name, id) { ids.add(id) })
+    this.assertEqual(n, ids.count())
+    resume()
+  },
+  
+  check_client_exists: function(name, exists, resume) {
+    var tc = this
+    tc.engine.clientExists(tc._clients[name], function(actual) {
+      tc.assertEqual(exists, actual)
+      resume()
+    })
+  },
+  
+  subscribe: function(name, channel, resume) {
+    this.engine.subscribe(this._clients[name], channel, resume)
+  },
+  
+  unsubscribe: function(name, channel, resume) {
+    this.engine.unsubscribe(this._clients[name], channel, resume)
+  },
+  
+  publish: function(messages, resume) {
+    messages = [].concat(messages)
+    Faye.each(messages, function(message) {
+      message = Faye.extend({id: Faye.random()}, message)
+      this.engine.publish(message)
+    }, this)
+    setTimeout(resume, 20)
+  },
+  
+  ping: function(name, resume) {
+    this.engine.ping(this._clients[name])
+    resume()
+  },
+  
+  clock_tick: function(time, resume) {
+    setTimeout(resume, time)
+  },
+  
+  expect_message: function(name, messages, resume) {
+    this.assertEqual(messages, this._inboxes[name])
+    resume()
+  },
+  
+  expect_no_message: function(name, resume) {
+    this.assertEqual([], this._inboxes[name])
+    resume()
+  },
+  
+  clean_redis_db: function(resume) {
+    this.engine.disconnect()
+    var redis = require('redis').createClient()
+    redis.flushall(function() {
+      redis.end()
+      resume()
+    })
+  }
+})
+
+JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this) {
+  include(JS.Test.Helpers)
+  
+  sharedExamplesFor("faye engine", function() { with(this) {
+    include(EngineSteps)
+    
+    define("options", function() { return {timeout: 1} })
+    
+    before(function() { with(this) {
+      this.engine = new engineKlass(options())
+      create_client("alice")
+      create_client("bob")
+      create_client("carol")
+    }})
+    
+    describe("createClient", function() { with(this) {
+      it("returns a client id", function() { with(this) {
+        create_client("dave")
+        check_client_id("dave", /^[a-z0-9]+$/)
+      }})
+      
+      it("returns a different id every time", function() { with(this) {
+        $R(1,7).forEach(function(i) { create_client("client" + i) })
+        check_num_clients(10)
+      }})
+    }})
+    
+    describe("clientExists", function() { with(this) {
+      it("returns true if the client id exists", function() { with(this) {
+        check_client_exists("alice", true)
+      }})
+      
+      it("returns false if the client id does not exist", function() { with(this) {
+        check_client_exists("anything", false)
+      }})
+    }})
+    
+    describe("ping", function() { with(this) {
+      define("options", function() { return {timeout: 0.3} })
+      
+      it("removes a client if it does not ping often enough", function() { with(this) {
+        clock_tick(700)
+        check_client_exists("alice", false)
+      }})
+      
+      it("prolongs the life of a client", function() { with(this) {
+        clock_tick(330)
+        ping("alice")
+        clock_tick(330)
+        check_client_exists("alice", true)
+        clock_tick(330)
+        check_client_exists("alice", false)
+      }})
+    }})
+    
+    describe("destroyClient", function() { with(this) {
+      it("removes the given client", function() { with(this) {
+        destroy_client("alice")
+        check_client_exists("alice", false)
+      }})
+
+      describe("when the client has subscriptions", function() { with(this) {
+        before(function() { with(this) {
+          this.message = {"channel": "/messages/foo", "data": "ok"}
+          subscribe("alice", "/messages/foo")
+        }})
+        
+        it("stops the client receiving messages", function() { with(this) {
+          connect("alice", engine)
+          destroy_client("alice")
+          publish(message)
+          expect_no_message("alice")
+        }})
+      }})
+    }})
+    
+    describe("publish", function() { with(this) {
+      before(function() { with(this) {
+        this.message = {"channel": "/messages/foo", "data": "ok"}
+        connect("alice", engine)
+        connect("bob", engine)
+        connect("carol", engine)
+      }})
+      
+      describe("with no subscriptions", function() { with(this) {
+        it("delivers no messages", function() { with(this) {
+          publish(message)
+          expect_no_message("alice")
+          expect_no_message("bob")
+          expect_no_message("carol")
+        }})
+      }})
+      
+      describe("with a subscriber", function() { with(this) {
+        before(function() { with(this) {
+          subscribe("alice", "/messages/foo")
+        }})
+        
+        it("delivers messages to the subscribed client", function() { with(this) {
+          publish(message)
+          expect_message("alice", [message])
+        }})
+      }})
+      
+      describe("with a subscriber that is removed", function() { with(this) {
+        before(function() { with(this) {
+          subscribe("alice", "/messages/foo")
+          unsubscribe("alice", "/messages/foo")
+        }})
+        
+        it("does not deliver messages to unsubscribed clients", function() { with(this) {
+          publish(message)
+          expect_no_message("alice")
+          expect_no_message("bob")
+          expect_no_message("carol")
+        }})
+      }})
+      
+      describe("with multiple subscribers", function() { with(this) {
+        before(function() { with(this) {
+          subscribe("alice", "/messages/foo")
+          subscribe("bob",   "/messages/bar")
+          subscribe("carol", "/messages/foo")
+        }})
+        
+        it("delivers messages to the subscribed clients", function() { with(this) {
+          publish(message)
+          expect_message("alice", [message])
+          expect_no_message("bob")
+          expect_message("carol", [message])
+        }})
+      }})
+      
+      describe("with a single wildcard", function() { with(this) {
+        before(function() { with(this) {
+          subscribe("alice", "/messages/*")
+          subscribe("bob",   "/messages/bar")
+          subscribe("carol", "/*")
+        }})
+        
+        it("delivers messages to matching subscriptions", function() { with(this) {
+          publish(message)
+          expect_message("alice", [message])
+          expect_no_message("bob")
+          expect_no_message("carol")
+        }})
+      }})
+      
+      describe("with a double wildcard", function() { with(this) {
+        before(function() { with(this) {
+          subscribe("alice", "/messages/**")
+          subscribe("bob",   "/messages/bar")
+          subscribe("carol", "/**")
+        }})
+        
+        it("delivers messages to matching subscriptions", function() { with(this) {
+          publish(message)
+          expect_message("alice", [message])
+          expect_no_message("bob")
+          expect_message("carol", [message])
+        }})
+      }})
+      
+      describe("with multiple matching subscriptions for the same client", function() { with(this) {
+        before(function() { with(this) {
+          subscribe("alice", "/messages/*")
+          subscribe("alice", "/messages/foo")
+        }})
+        
+        it("delivers each message once to each client", function() { with(this) {
+          publish(message)
+          expect_message("alice", [message])
+        }})
+        
+        it("delivers the message as many times as it is published", function() { with(this) {
+          publish([message, message])
+          expect_message("alice", [message, message])
+        }})
+      }})
+    }})
+  }})
+  
+  sharedBehavior("distributed engine", function() { with(this) {
+    include(EngineSteps)
+    define("options", function() { return {timeout: 1} })
+    
+    before(function() { with(this) {
+      this.left   = new engineKlass(options())
+      this.right  = new engineKlass(options())
+      this.engine = left
+      
+      create_client("alice")
+      create_client("bob")
+      
+      connect("alice", left)
+    }})
+    
+    describe("publish", function() { with(this) {
+      before(function() { with(this) {
+        subscribe("alice", "/foo")
+        publish({channel: "/foo", data: "first"})
+      }})
+      
+      it("only delivers each message once", function() { with(this) {
+        expect_message("alice", [{channel: "/foo", data: "first"}])
+        publish({channel: "/foo", data: "second"})
+        connect("alice", right)
+        expect_message("alice", [{channel: "/foo", data: "first"}, {channel: "/foo", data: "second"}])
+      }})
+    }})
+  }})
+  
+  describe("Faye.Engine.Memory", function() { with(this) {
+    before(function() { this.engineKlass = Faye.Engine.Memory })
+    itShouldBehaveLike("faye engine")
+  }})
+  
+  describe("Faye.Engine.Redis", function() { with(this) {
+    before(function() { this.engineKlass = Faye.Engine.Redis })
+    after(function() { this.clean_redis_db() })
+    itShouldBehaveLike("faye engine")
+    describe("distribution", function() { with(this) {
+      itShouldBehaveLike("distributed engine")
+    }})
+  }})
+}})

data/spec/javascript/faye_spec.js

@@ -0,0 +1,15 @@
+JS.ENV.FayeSpec = JS.Test.describe("Faye", function() { with(this) {
+  include(JS.Test.Helpers)
+  
+  describe("random", function() { with(this) {
+    it("returns a 128-bit random number in base 36", function() { with(this) {
+      assertMatch( /^[a-z0-9]+$/, Faye.random() )
+    }})
+    
+    it("always produces the same length of string", function() { with(this) {
+      var ids = $R(1,100).map(function() { return Faye.random().length })
+      var expected = $R(1,100).map(function() { return 28 })
+      assertEqual( expected, ids )
+    }})
+  }})
+}})

data/spec/javascript/grammar_spec.js

@@ -0,0 +1,66 @@
+JS.ENV.GrammarSpec = JS.Test.describe("Grammar", function() { with(this) {
+  describe("CHANNEL_NAME", function() { with(this) {
+    it("matches valid channel names", function() { with(this) {
+      assertMatch( Faye.Grammar.CHANNEL_NAME, "/fo_o/$@()bar" )
+    }})
+    
+    it("does not match channel patterns", function() { with(this) {
+      assertNoMatch( Faye.Grammar.CHANNEL_NAME, "/foo/**" )
+    }})
+    
+    it("does not match invalid channel names", function() { with(this) {
+      assertNoMatch( Faye.Grammar.CHANNEL_NAME, "foo/$@()bar" )
+      assertNoMatch( Faye.Grammar.CHANNEL_NAME, "/foo/$@()bar/" )
+      assertNoMatch( Faye.Grammar.CHANNEL_NAME, "/fo o/$@()bar" )
+    }})
+  }})
+  
+  describe("CHANNEL_PATTERN", function() { with(this) {
+    it("does not match channel names", function() { with(this) {
+      assertNoMatch( Faye.Grammar.CHANNEL_PATTERN, "/fo_o/$@()bar" )
+    }})
+    
+    it("matches valid channel patterns", function() { with(this) {
+      assertMatch( Faye.Grammar.CHANNEL_PATTERN, "/foo/**" )
+      assertMatch( Faye.Grammar.CHANNEL_PATTERN, "/foo/*" )
+    }})
+    
+    it("does not match invalid channel patterns", function() { with(this) {
+      assertNoMatch( Faye.Grammar.CHANNEL_PATTERN, "/foo/**/*" )
+    }})
+  }})
+  
+  describe("ERROR", function() { with(this) {
+    it("matches an error with an argument", function() { with(this) {
+      assertMatch( Faye.Grammar.ERROR, "402:xj3sjdsjdsjad:Unknown Client ID" )
+    }})
+    
+    it("matches an error with many arguments", function() { with(this) {
+      assertMatch( Faye.Grammar.ERROR, "403:xj3sjdsjdsjad,/foo/bar:Subscription denied" )
+    }})
+    
+    it("matches an error with no arguments", function() { with(this) {
+      assertMatch( Faye.Grammar.ERROR, "402::Unknown Client ID" )
+    }})
+    
+    it("does not match an error with no code", function() { with(this) {
+      assertNoMatch( Faye.Grammar.ERROR, ":xj3sjdsjdsjad:Unknown Client ID" )
+    }})
+    
+    it("does not match an error with an invalid code", function() { with(this) {
+      assertNoMatch( Faye.Grammar.ERROR, "40:xj3sjdsjdsjad:Unknown Client ID" )
+    }})
+  }})
+  
+  describe("VERSION", function() { with(this) {
+    it("matches a version number", function() { with(this) {
+      assertMatch( Faye.Grammar.VERSION, "9" )
+      assertMatch( Faye.Grammar.VERSION, "9.0.a-delta1" )
+    }})
+    
+    it("does not match invalid version numbers", function() { with(this) {
+      assertNoMatch( Faye.Grammar.VERSION, "9.0.a-delta1." )
+      assertNoMatch( Faye.Grammar.VERSION, "" )
+    }})
+  }})
+}})

data/spec/javascript/node_adapter_spec.js

@@ -0,0 +1,276 @@
+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)
+    setTimeout(resume, 50)
+  },
+  
+  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_content_type: function(type, resume) {
+    this.assertEqual(type, this._response.headers["content-type"])
+    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) {
+      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: "/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_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("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_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_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_body('callback([{"channel":"/meta/handshake"}]);')
+      }})
+    }})
+    
+    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_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\(\)\{/)
+      }})
+    }})
+  }})
+}})