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/ruby/server/publish_spec.rb ADDED Viewed

@@ -0,0 +1,81 @@
+require "spec_helper"
+describe "server publish" do
+  let(:engine)  { mock "engine" }
+  let(:server)  { Faye::Server.new }
+  let(:message) {{ "channel" => "/some/channel", "data" => "publish" }}
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  describe "publishing a message" do
+    it "tells the engine to publish the message" do
+      engine.should_receive(:publish).with(message)
+      server.process(message, false) {}
+    end
+    it "returns a successful response" do
+      engine.stub(:publish)
+      server.process(message, false) do |response|
+        response.should == [
+          { "channel"     => "/some/channel",
+            "successful"  => true
+          }
+        ]
+      end
+    end
+    describe "with an invalid channel" do
+      before { message["channel"] = "channel" }
+      it "does not tell the engine to publish the message" do
+        engine.should_not_receive(:publish)
+        server.process(message, false) {}
+      end
+      it "returns an unsuccessful response" do
+        engine.stub(:publish)
+        server.process(message, false) do |response|
+          response.should == [
+            { "channel"     => "channel",
+              "successful"  => false,
+              "error"       => "405:channel:Invalid channel"
+            }
+          ]
+        end
+      end
+    end
+    describe "with an error" do
+      before { message["error"] = "invalid" }
+      it "does not tell the engine to publish the message" do
+        engine.should_not_receive(:publish)
+        server.process(message, false) {}
+      end
+      it "returns an unsuccessful response" do
+        engine.stub(:publish)
+        server.process(message, false) do |response|
+          response.should == [
+            { "channel"     => "/some/channel",
+              "successful"  => false,
+              "error"       => "invalid"
+            }
+          ]
+        end
+      end
+    end
+    describe "to an invalid channel" do
+      before { message["channel"] = "/invalid/*" }
+      it "does not tell the engine to publish the message" do
+        engine.should_not_receive(:publish)
+        server.process(message, false) {}
+      end
+    end
+  end
+end

data/spec/ruby/server/subscribe_spec.rb ADDED Viewed

@@ -0,0 +1,247 @@
+require "spec_helper"
+describe "server subscribe" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  describe :subscribe do
+    let(:client_id) { "fakeclientid" }
+    let(:message) {{"channel" => "/meta/subscribe",
+                    "clientId" => "fakeclientid",
+                    "subscription" => "/foo"
+                  }}
+    describe "with valid parameters" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "subscribes the client to the channel" do
+        engine.should_receive(:subscribe).with(client_id, "/foo")
+        server.subscribe(message) {}
+      end
+      it "returns a successful response" do
+        engine.stub(:subscribe)
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => true,
+            "clientId"     => client_id,
+            "subscription" => "/foo"
+          }
+        end
+      end
+      describe "with a list of subscriptions" do
+        before do
+          message["subscription"] = ["/foo", "/bar"]
+        end
+        it "creates multiple subscriptions" do
+          engine.should_receive(:subscribe).with(client_id, "/foo")
+          engine.should_receive(:subscribe).with(client_id, "/bar")
+          server.subscribe(message) {}
+        end
+        it "returns a successful response" do
+          engine.stub(:subscribe)
+          server.subscribe(message) do |response|
+            response.should == {
+              "channel"      => "/meta/subscribe",
+              "successful"   => true,
+              "clientId"     => client_id,
+              "subscription" => ["/foo", "/bar"]
+            }
+          end
+        end
+      end
+      describe "with a subscription pattern" do
+        before do
+          message["subscription"] = "/foo/**"
+        end
+        it "subscribes the client to the channel pattern" do
+          engine.should_receive(:subscribe).with(client_id, "/foo/**")
+          server.subscribe(message) {}
+        end
+        it "returns a successful response" do
+          engine.stub(:subscribe)
+          server.subscribe(message) do |response|
+            response.should == {
+              "channel"      => "/meta/subscribe",
+              "successful"   => true,
+              "clientId"     => client_id,
+              "subscription" => "/foo/**"
+            }
+          end
+        end
+      end
+    end
+    describe "with an unknown client" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield false
+      end
+      it "does not subscribe the client to the channel" do
+        engine.should_not_receive(:subscribe)
+        server.subscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => false,
+            "error"        => "401:fakeclientid:Unknown client",
+            "clientId"     => client_id,
+            "subscription" => "/foo"
+          }
+        end
+      end
+    end
+    describe "missing clientId" do
+      before do
+        message.delete("clientId")
+        engine.should_receive(:client_exists).with(nil).and_yield false
+      end
+      it "does not subscribe the client to the channel" do
+        engine.should_not_receive(:subscribe)
+        server.subscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => false,
+            "error"        => "402:clientId:Missing required parameter",
+            "subscription" => "/foo"
+          }
+        end
+      end
+    end
+    describe "missing subscription" do
+      before do
+        message.delete("subscription")
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not subscribe the client to the channel" do
+        engine.should_not_receive(:subscribe)
+        server.subscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => false,
+            "error"        => "402:subscription:Missing required parameter",
+            "clientId"     => client_id,
+            "subscription" => []
+          }
+        end
+      end
+    end
+    describe "with an invalid channel" do
+      before do
+        message["subscription"] = "foo"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not subscribe the client to the channel" do
+        engine.should_not_receive(:subscribe)
+        server.subscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => false,
+            "error"        => "405:foo:Invalid channel",
+            "clientId"     => client_id,
+            "subscription" => "foo"
+          }
+        end
+      end
+    end
+    describe "with a /meta/* channel" do
+      before do
+        message["subscription"] = "/meta/foo"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not subscribe the client to the channel" do
+        engine.should_not_receive(:subscribe)
+        server.subscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => false,
+            "error"        => "403:/meta/foo:Forbidden channel",
+            "clientId"     => client_id,
+            "subscription" => "/meta/foo"
+          }
+        end
+      end
+      it "subscribes local clients to the channel" do
+        engine.should_receive(:subscribe).with(client_id, "/meta/foo")
+        server.subscribe(message, true) {}
+      end
+      it "returns a successful response for local clients" do
+        engine.stub(:subscribe)
+        server.subscribe(message, true) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => true,
+            "clientId"     => client_id,
+            "subscription" => "/meta/foo"
+          }
+        end
+      end
+    end
+    describe "with an error" do
+      before do
+        message["error"] = "invalid"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not subscribe the client to the channel" do
+        engine.should_not_receive(:subscribe)
+        server.subscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.subscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/subscribe",
+            "successful"   => false,
+            "error"        => "invalid",
+            "clientId"     => client_id,
+            "subscription" => "/foo"
+          }
+        end
+      end
+    end
+  end
+end

data/spec/ruby/server/unsubscribe_spec.rb ADDED Viewed

@@ -0,0 +1,247 @@
+require "spec_helper"
+describe "server unsubscribe" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  describe :unsubscribe do
+    let(:client_id) { "fakeclientid" }
+    let(:message) {{"channel" => "/meta/unsubscribe",
+                    "clientId" => "fakeclientid",
+                    "subscription" => "/foo"
+                  }}
+    describe "with valid parameters" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "unsubscribes the client from the channel" do
+        engine.should_receive(:unsubscribe).with(client_id, "/foo")
+        server.unsubscribe(message) {}
+      end
+      it "returns a successful response" do
+        engine.stub(:unsubscribe)
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => true,
+            "clientId"     => client_id,
+            "subscription" => "/foo"
+          }
+        end
+      end
+      describe "with a list of subscriptions" do
+        before do
+          message["subscription"] = ["/foo", "/bar"]
+        end
+        it "destroys multiple subscriptions" do
+          engine.should_receive(:unsubscribe).with(client_id, "/foo")
+          engine.should_receive(:unsubscribe).with(client_id, "/bar")
+          server.unsubscribe(message) {}
+        end
+        it "returns a successful response" do
+          engine.stub(:unsubscribe)
+          server.unsubscribe(message) do |response|
+            response.should == {
+              "channel"      => "/meta/unsubscribe",
+              "successful"   => true,
+              "clientId"     => client_id,
+              "subscription" => ["/foo", "/bar"]
+            }
+          end
+        end
+      end
+      describe "with a subscription pattern" do
+        before do
+          message["subscription"] = "/foo/**"
+        end
+        it "destroys the subscription to the channel pattern" do
+          engine.should_receive(:unsubscribe).with(client_id, "/foo/**")
+          server.unsubscribe(message) {}
+        end
+        it "returns a successful response" do
+          engine.stub(:unsubscribe)
+          server.unsubscribe(message) do |response|
+            response.should == {
+              "channel"      => "/meta/unsubscribe",
+              "successful"   => true,
+              "clientId"     => client_id,
+              "subscription" => "/foo/**"
+            }
+          end
+        end
+      end
+    end
+    describe "with an unknown client" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield false
+      end
+      it "does not unsubscribe the client from the channel" do
+        engine.should_not_receive(:unsubscribe)
+        server.unsubscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => false,
+            "error"        => "401:fakeclientid:Unknown client",
+            "clientId"     => client_id,
+            "subscription" => "/foo"
+          }
+        end
+      end
+    end
+    describe "missing clientId" do
+      before do
+        message.delete("clientId")
+        engine.should_receive(:client_exists).with(nil).and_yield false
+      end
+      it "does not unsubscribe the client from the channel" do
+        engine.should_not_receive(:unsubscribe)
+        server.unsubscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => false,
+            "error"        => "402:clientId:Missing required parameter",
+            "subscription" => "/foo"
+          }
+        end
+      end
+    end
+    describe "missing subscription" do
+      before do
+        message.delete("subscription")
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not unsubscribe the client from the channel" do
+        engine.should_not_receive(:unsubscribe)
+        server.unsubscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => false,
+            "error"        => "402:subscription:Missing required parameter",
+            "clientId"     => client_id,
+            "subscription" => []
+          }
+        end
+      end
+    end
+    describe "with an invalid channel" do
+      before do
+        message["subscription"] = "foo"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not unsubscribe the client from the channel" do
+        engine.should_not_receive(:unsubscribe)
+        server.unsubscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => false,
+            "error"        => "405:foo:Invalid channel",
+            "clientId"     => client_id,
+            "subscription" => "foo"
+          }
+        end
+      end
+    end
+    describe "with a /meta/* channel" do
+      before do
+        message["subscription"] = "/meta/foo"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not unsubscribe the client from the channel" do
+        engine.should_not_receive(:unsubscribe)
+        server.unsubscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => false,
+            "error"        => "403:/meta/foo:Forbidden channel",
+            "clientId"     => client_id,
+            "subscription" => "/meta/foo"
+          }
+        end
+      end
+      it "unsubscribes local clients from the channel" do
+        engine.should_receive(:unsubscribe).with(client_id, "/meta/foo")
+        server.unsubscribe(message, true) {}
+      end
+      it "returns a successful response for local clients" do
+        engine.stub(:unsubscribe)
+        server.unsubscribe(message, true) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => true,
+            "clientId"     => client_id,
+            "subscription" => "/meta/foo"
+          }
+        end
+      end
+    end
+    describe "with an error" do
+      before do
+        message["error"] = "invalid"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      it "does not unsubscribe the client from the channel" do
+        engine.should_not_receive(:unsubscribe)
+        server.unsubscribe(message) {}
+      end
+      it "returns an unsuccessful response" do
+        server.unsubscribe(message) do |response|
+          response.should == {
+            "channel"      => "/meta/unsubscribe",
+            "successful"   => false,
+            "error"        => "invalid",
+            "clientId"     => client_id,
+            "subscription" => "/foo"
+          }
+        end
+      end
+    end
+  end
+end