RubyGems - faye - Versions diffs - 0.5.5 → 0.6.0 - Mend

faye 0.5.5 → 0.6.0

Potentially problematic release.

This version of faye might be problematic. Click here for more details.

Files changed (62) hide show

data/History.txt +14 -0
data/README.rdoc +98 -0
data/Rakefile +17 -15
data/lib/faye-browser-min.js +1 -1
data/lib/faye.rb +14 -5
data/lib/faye/adapters/rack_adapter.rb +12 -5
data/lib/faye/engines/base.rb +62 -0
data/lib/faye/engines/connection.rb +63 -0
data/lib/faye/engines/memory.rb +89 -0
data/lib/faye/engines/redis.rb +141 -0
data/lib/faye/error.rb +16 -4
data/lib/faye/mixins/publisher.rb +6 -0
data/lib/faye/protocol/channel.rb +34 -86
data/lib/faye/protocol/client.rb +36 -52
data/lib/faye/protocol/extensible.rb +3 -0
data/lib/faye/protocol/server.rb +119 -169
data/lib/faye/transport/http.rb +45 -0
data/lib/faye/transport/local.rb +15 -0
data/lib/faye/{network → transport}/transport.rb +36 -49
data/spec/browser.html +35 -0
data/spec/install.sh +48 -0
data/spec/javascript/channel_spec.js +15 -0
data/spec/javascript/client_spec.js +610 -0
data/spec/javascript/engine_spec.js +319 -0
data/spec/javascript/faye_spec.js +15 -0
data/spec/javascript/grammar_spec.js +66 -0
data/spec/javascript/node_adapter_spec.js +276 -0
data/spec/javascript/server/connect_spec.js +168 -0
data/spec/javascript/server/disconnect_spec.js +121 -0
data/spec/javascript/server/extensions_spec.js +60 -0
data/spec/javascript/server/handshake_spec.js +153 -0
data/spec/javascript/server/subscribe_spec.js +245 -0
data/spec/javascript/server/unsubscribe_spec.js +245 -0
data/spec/javascript/server_spec.js +146 -0
data/spec/javascript/transport_spec.js +130 -0
data/spec/node.js +34 -0
data/spec/ruby/channel_spec.rb +17 -0
data/spec/ruby/client_spec.rb +615 -0
data/spec/ruby/engine_spec.rb +312 -0
data/spec/ruby/faye_spec.rb +14 -0
data/spec/ruby/grammar_spec.rb +68 -0
data/spec/ruby/rack_adapter_spec.rb +209 -0
data/spec/ruby/server/connect_spec.rb +170 -0
data/spec/ruby/server/disconnect_spec.rb +120 -0
data/spec/ruby/server/extensions_spec.rb +69 -0
data/spec/ruby/server/handshake_spec.rb +151 -0
data/spec/ruby/server/subscribe_spec.rb +247 -0
data/spec/ruby/server/unsubscribe_spec.rb +247 -0
data/spec/ruby/server_spec.rb +138 -0
data/spec/ruby/transport_spec.rb +128 -0
data/spec/spec_helper.rb +5 -0
data/spec/testswarm.pl +200 -0
data/spec/thin_proxy.rb +36 -0
metadata +119 -84
data/Manifest.txt +0 -27
data/README.txt +0 -98
data/lib/faye/protocol/connection.rb +0 -111
data/test/scenario.rb +0 -172
data/test/test_channel.rb +0 -54
data/test/test_clients.rb +0 -381
data/test/test_grammar.rb +0 -86
data/test/test_server.rb +0 -488

data/spec/javascript/server/subscribe_spec.js ADDED Viewed

@@ -0,0 +1,245 @@
+JS.ENV.Server.SubscribeSpec = JS.Test.describe("Server subscribe", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+  }})
+  describe("#subscribe", function() { with(this) {
+    before(function() { with(this) {
+      this.clientId = "fakeclientid"
+      this.message = {channel: "/meta/subscribe",
+                      clientId: "fakeclientid",
+                      subscription: "/foo"}
+    }})
+    describe("with valid parameters", function() { with(this) {
+      before(function() { with(this) {
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("subscribes the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").given(clientId, "/foo")
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns a successful response", function() { with(this) {
+        stub(engine, "subscribe")
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   true,
+              clientId:     clientId,
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+      describe("with a list of subscriptions", function() { with(this) {
+        before(function() { with(this) {
+          message.subscription = ["/foo", "/bar"]
+        }})
+        it("creates multiple subscriptions", function() { with(this) {
+          expect(engine, "subscribe").given(clientId, "/foo")
+          expect(engine, "subscribe").given(clientId, "/bar")
+          server.subscribe(message, false, function() {})
+        }})
+        it("returns a successful response", function() { with(this) {
+          stub(engine, "subscribe")
+          server.subscribe(message, false, function(response) {
+            assertEqual({
+                channel:      "/meta/subscribe",
+                successful:   true,
+                clientId:     clientId,
+                subscription: ["/foo", "/bar"]
+              }, response)
+          })
+        }})
+      }})
+      describe("with a subscription pattern", function() { with(this) {
+        before(function() { with(this) {
+          message.subscription = "/foo/**"
+        }})
+        it("subscribes the client to the channel pattern", function() { with(this) {
+          expect(engine, "subscribe").given(clientId, "/foo/**")
+          server.subscribe(message, false, function() {})
+        }})
+        it("returns a successful response", function() { with(this) {
+          stub(engine, "subscribe")
+          server.subscribe(message, false, function(response) {
+            assertEqual({
+                channel:      "/meta/subscribe",
+                successful:   true,
+                clientId:     clientId,
+                subscription: "/foo/**"
+              }, response)
+          })
+        }})
+      }})
+    }})
+    describe("with an unknown client", function() { with(this) {
+      before(function() { with(this) {
+        expect(engine, "clientExists").given(clientId).yielding([false])
+      }})
+      it("does not subscribe the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").exactly(0)
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   false,
+              error:        "401:fakeclientid:Unknown client",
+              clientId:     clientId,
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+    }})
+    describe("missing clientId", function() { with(this) {
+      before(function() { with(this) {
+        delete message.clientId
+        expect(engine, "clientExists").given(undefined).yielding([false])
+      }})
+      it("does not subscribe the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").exactly(0)
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   false,
+              error:        "402:clientId:Missing required parameter",
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+    }})
+    describe("missing subscription", function() { with(this) {
+      before(function() { with(this) {
+        delete message.subscription
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("does not subscribe the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").exactly(0)
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   false,
+              error:        "402:subscription:Missing required parameter",
+              clientId:     clientId,
+              subscription: []
+            }, response)
+        })
+      }})
+    }})
+    describe("with an invalid channel", function() { with(this) {
+      before(function() { with(this) {
+        message.subscription = "foo"
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("does not subscribe the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").exactly(0)
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   false,
+              error:        "405:foo:Invalid channel",
+              clientId:     clientId,
+              subscription: "foo"
+            }, response)
+        })
+      }})
+    }})
+    describe("with a /meta/* channel", function() { with(this) {
+      before(function() { with(this) {
+        message.subscription = "/meta/foo"
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("does not subscribe the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").exactly(0)
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   false,
+              error:        "403:/meta/foo:Forbidden channel",
+              clientId:     clientId,
+              subscription: "/meta/foo"
+            }, response)
+        })
+      }})
+      it("subscribes local clients to the channel", function() { with(this) {
+        expect(engine, "subscribe").given(clientId, "/meta/foo")
+        server.subscribe(message, true, function() {})
+      }})
+      it("returns a successful response for local clients", function() { with(this) {
+        stub(engine, "subscribe")
+        server.subscribe(message, true, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   true,
+              clientId:     clientId,
+              subscription: "/meta/foo"
+            }, 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 subscribe the client to the channel", function() { with(this) {
+        expect(engine, "subscribe").exactly(0)
+        server.subscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.subscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/subscribe",
+              successful:   false,
+              error:        "invalid",
+              clientId:     clientId,
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+    }})
+  }})
+}})

data/spec/javascript/server/unsubscribe_spec.js ADDED Viewed

@@ -0,0 +1,245 @@
+JS.ENV.Server.UnsubscribeSpec = JS.Test.describe("Server unsubscribe", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+  }})
+  describe("#unsubscribe", function() { with(this) {
+    before(function() { with(this) {
+      this.clientId = "fakeclientid"
+      this.message = {channel: "/meta/unsubscribe",
+                      clientId: "fakeclientid",
+                      subscription: "/foo"}
+    }})
+    describe("with valid parameters", function() { with(this) {
+      before(function() { with(this) {
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("unsubscribes the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").given(clientId, "/foo")
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns a successful response", function() { with(this) {
+        stub(engine, "unsubscribe")
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   true,
+              clientId:     clientId,
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+      describe("with a list of subscriptions", function() { with(this) {
+        before(function() { with(this) {
+          message.subscription = ["/foo", "/bar"]
+        }})
+        it("destroys multiple subscriptions", function() { with(this) {
+          expect(engine, "unsubscribe").given(clientId, "/foo")
+          expect(engine, "unsubscribe").given(clientId, "/bar")
+          server.unsubscribe(message, false, function() {})
+        }})
+        it("returns a successful response", function() { with(this) {
+          stub(engine, "unsubscribe")
+          server.unsubscribe(message, false, function(response) {
+            assertEqual({
+                channel:      "/meta/unsubscribe",
+                successful:   true,
+                clientId:     clientId,
+                subscription: ["/foo", "/bar"]
+              }, response)
+          })
+        }})
+      }})
+      describe("with a subscription pattern", function() { with(this) {
+        before(function() { with(this) {
+          message.subscription = "/foo/**"
+        }})
+        it("destroys the subscription to the channel pattern", function() { with(this) {
+          expect(engine, "unsubscribe").given(clientId, "/foo/**")
+          server.unsubscribe(message, false, function() {})
+        }})
+        it("returns a successful response", function() { with(this) {
+          stub(engine, "unsubscribe")
+          server.unsubscribe(message, false, function(response) {
+            assertEqual({
+                channel:      "/meta/unsubscribe",
+                successful:   true,
+                clientId:     clientId,
+                subscription: "/foo/**"
+              }, response)
+          })
+        }})
+      }})
+    }})
+    describe("with an unknown client", function() { with(this) {
+      before(function() { with(this) {
+        expect(engine, "clientExists").given(clientId).yielding([false])
+      }})
+      it("does not unsubscribe the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").exactly(0)
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   false,
+              error:        "401:fakeclientid:Unknown client",
+              clientId:     clientId,
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+    }})
+    describe("missing clientId", function() { with(this) {
+      before(function() { with(this) {
+        delete message.clientId
+        expect(engine, "clientExists").given(undefined).yielding([false])
+      }})
+      it("does not unsubscribe the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").exactly(0)
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   false,
+              error:        "402:clientId:Missing required parameter",
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+    }})
+    describe("missing subscription", function() { with(this) {
+      before(function() { with(this) {
+        delete message.subscription
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("does not unsubscribe the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").exactly(0)
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   false,
+              error:        "402:subscription:Missing required parameter",
+              clientId:     clientId,
+              subscription: []
+            }, response)
+        })
+      }})
+    }})
+    describe("with an invalid channel", function() { with(this) {
+      before(function() { with(this) {
+        message.subscription = "foo"
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("does not unsubscribe the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").exactly(0)
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   false,
+              error:        "405:foo:Invalid channel",
+              clientId:     clientId,
+              subscription: "foo"
+            }, response)
+        })
+      }})
+    }})
+    describe("with a /meta/* channel", function() { with(this) {
+      before(function() { with(this) {
+        message.subscription = "/meta/foo"
+        expect(engine, "clientExists").given(clientId).yielding([true])
+      }})
+      it("does not unsubscribe the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").exactly(0)
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   false,
+              error:        "403:/meta/foo:Forbidden channel",
+              clientId:     clientId,
+              subscription: "/meta/foo"
+            }, response)
+        })
+      }})
+      it("unsubscribes local clients from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").given(clientId, "/meta/foo")
+        server.unsubscribe(message, true, function() {})
+      }})
+      it("returns a successful response for local clients", function() { with(this) {
+        stub(engine, "unsubscribe")
+        server.unsubscribe(message, true, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   true,
+              clientId:     clientId,
+              subscription: "/meta/foo"
+            }, 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 unsubscribe the client from the channel", function() { with(this) {
+        expect(engine, "unsubscribe").exactly(0)
+        server.unsubscribe(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        server.unsubscribe(message, false, function(response) {
+          assertEqual({
+              channel:      "/meta/unsubscribe",
+              successful:   false,
+              error:        "invalid",
+              clientId:     clientId,
+              subscription: "/foo"
+            }, response)
+        })
+      }})
+    }})
+  }})
+}})