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/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