RubyGems - bushido-faye - Versions diffs - 0.8.1 - Mend

bushido-faye 0.8.1

Files changed (69) hide show

data/History.txt +247 -0
data/README.rdoc +92 -0
data/lib/faye-browser-min.js +1 -0
data/lib/faye.rb +121 -0
data/lib/faye/adapters/rack_adapter.rb +209 -0
data/lib/faye/engines/connection.rb +60 -0
data/lib/faye/engines/memory.rb +112 -0
data/lib/faye/engines/proxy.rb +111 -0
data/lib/faye/error.rb +49 -0
data/lib/faye/mixins/logging.rb +47 -0
data/lib/faye/mixins/publisher.rb +30 -0
data/lib/faye/mixins/timeouts.rb +22 -0
data/lib/faye/protocol/channel.rb +124 -0
data/lib/faye/protocol/client.rb +378 -0
data/lib/faye/protocol/extensible.rb +43 -0
data/lib/faye/protocol/grammar.rb +58 -0
data/lib/faye/protocol/publication.rb +5 -0
data/lib/faye/protocol/server.rb +282 -0
data/lib/faye/protocol/subscription.rb +24 -0
data/lib/faye/transport/http.rb +76 -0
data/lib/faye/transport/local.rb +22 -0
data/lib/faye/transport/transport.rb +115 -0
data/lib/faye/transport/web_socket.rb +99 -0
data/lib/faye/util/namespace.rb +20 -0
data/spec/browser.html +45 -0
data/spec/encoding_helper.rb +7 -0
data/spec/install.sh +78 -0
data/spec/javascript/channel_spec.js +15 -0
data/spec/javascript/client_spec.js +714 -0
data/spec/javascript/engine/memory_spec.js +7 -0
data/spec/javascript/engine_spec.js +417 -0
data/spec/javascript/faye_spec.js +15 -0
data/spec/javascript/grammar_spec.js +66 -0
data/spec/javascript/node_adapter_spec.js +307 -0
data/spec/javascript/publisher_spec.js +27 -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 +145 -0
data/spec/javascript/server/integration_spec.js +124 -0
data/spec/javascript/server/publish_spec.js +85 -0
data/spec/javascript/server/subscribe_spec.js +247 -0
data/spec/javascript/server/unsubscribe_spec.js +245 -0
data/spec/javascript/server_spec.js +110 -0
data/spec/javascript/transport_spec.js +130 -0
data/spec/node.js +55 -0
data/spec/phantom.js +17 -0
data/spec/ruby/channel_spec.rb +17 -0
data/spec/ruby/client_spec.rb +724 -0
data/spec/ruby/engine/memory_spec.rb +7 -0
data/spec/ruby/engine_examples.rb +427 -0
data/spec/ruby/faye_spec.rb +14 -0
data/spec/ruby/grammar_spec.rb +68 -0
data/spec/ruby/publisher_spec.rb +27 -0
data/spec/ruby/rack_adapter_spec.rb +236 -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 +68 -0
data/spec/ruby/server/handshake_spec.rb +143 -0
data/spec/ruby/server/integration_spec.rb +126 -0
data/spec/ruby/server/publish_spec.rb +81 -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 +110 -0
data/spec/ruby/transport_spec.rb +134 -0
data/spec/spec_helper.rb +11 -0
data/spec/testswarm +29 -0
data/spec/thin_proxy.rb +37 -0
metadata +302 -0

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

@@ -0,0 +1,85 @@
+JS.ENV.Server.PublishSpec = JS.Test.describe("Server publish", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+    this.message = {channel: "/some/channel",     data: "publish"}
+  }})
+  describe("publishing a message", function() { with(this) {
+    it("tells the engine to publish the message", function() { with(this) {
+      expect(engine, "publish").given(message)
+      server.process(message, false, function() {})
+    }})
+    it("returns a successful response", function() { with(this) {
+      stub(engine, "publish")
+      server.process(message, false, function(response) {
+        assertEqual([
+          { channel:    "/some/channel",
+            successful: true
+          }
+        ], response)
+      })
+    }})
+    describe("with an invalid channel", function() { with(this) {
+      before(function() { with(this) {
+        message.channel = "channel"
+      }})
+      it("does not tell the engine to publish the message", function() { with(this) {
+        expect(engine, "publish").exactly(0)
+        server.process(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "publish")
+        server.process(message, false, function(response) {
+          assertEqual([
+            { channel:    "channel",
+              successful: false,
+              error:      "405:channel:Invalid channel"
+            }
+          ], response)
+        })
+      }})
+    }})
+    describe("with an error", function() { with(this) {
+      before(function() { with(this) {
+        message.error = "invalid"
+      }})
+      it("does not tell the engine to publish the message", function() { with(this) {
+        expect(engine, "publish").exactly(0)
+        server.process(message, false, function() {})
+      }})
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "publish")
+        server.process(message, false, function(response) {
+          assertEqual([
+            { channel:    "/some/channel",
+              successful: false,
+              error:      "invalid"
+            }
+          ], response)
+        })
+      }})
+    }})
+    describe("to an invalid channel", function() { with(this) {
+      before(function() { with(this) {
+        message.channel = "/invalid/*"
+      }})
+      it("does not tell the engine to publish the message", function() { with(this) {
+        expect(engine, "publish").exactly(0)
+        server.process(message, false, function() {})
+      }})
+    }})
+  }})
+}})

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

@@ -0,0 +1,247 @@
+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(resume) { with(this) {
+        server.subscribe(message, false, function(response) {
+          resume(function() {
+            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)
+        })
+      }})
+    }})
+  }})
+}})