faye 0.8.11 → 1.0.0

data/spec/ruby/server/publish_spec.rb

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

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

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