faye 0.8.11 → 1.0.0

data/spec/javascript/faye_spec.js

@@ -1,34 +0,0 @@
-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 35 })
-      assertEqual( expected, ids )
-    }})
-  }})
-
-  describe("copyObject", function() { with(this) {
-    before(function() { with(this) {
-      this.object = {foo: "bar", qux: 42, hey: null, obj: {bar: 67}}
-    }})
-
-    it("returns an equal object", function() { with(this) {
-      assertEqual( {foo: "bar", qux: 42, hey: null, obj: {bar: 67}},
-                   Faye.copyObject(object) )
-    }})
-
-    it("does not return the same object", function() { with(this) {
-      assertNotSame( object, Faye.copyObject(object) )
-    }})
-
-    it("performs a deep clone", function() { with(this) {
-      assertNotSame( object.obj, Faye.copyObject(object).obj )
-    }})
-  }})
-}})

data/spec/javascript/grammar_spec.js

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

@@ -1,314 +0,0 @@
-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 + "; charset=utf-8", 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("46")
-        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("51")
-        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("with a callback that's not a JS identifier", function() { with(this) {
-      before(function() { with(this) {
-        params.jsonp = "42"
-      }})
-      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

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

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