faye 0.8.8 → 0.8.9

data/spec/ruby/server/unsubscribe_spec.rb

@@ -3,28 +3,28 @@ 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|
@@ -36,18 +36,18 @@ describe "server unsubscribe" do
           }
         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|
@@ -60,17 +60,17 @@ describe "server unsubscribe" do
           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|
@@ -84,17 +84,17 @@ describe "server unsubscribe" do
         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 == {
@@ -107,18 +107,18 @@ describe "server unsubscribe" do
         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 == {
@@ -130,18 +130,18 @@ describe "server unsubscribe" do
         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 == {
@@ -154,18 +154,18 @@ describe "server unsubscribe" do
         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 == {
@@ -178,18 +178,18 @@ describe "server unsubscribe" do
         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 == {
@@ -201,12 +201,12 @@ describe "server unsubscribe" do
           }
         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|
@@ -219,18 +219,18 @@ describe "server unsubscribe" do
         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 == {

data/spec/ruby/server_spec.rb

@@ -3,11 +3,11 @@ require "spec_helper"
 describe Faye::Server do
   let(:engine) { mock "engine" }
   let(:server) { Faye::Server.new }
-  
+
   before do
     Faye::Engine.stub(:get).and_return engine
   end
-  
+
   describe :process do
     let(:handshake)   {{"channel" => "/meta/handshake",   "data" => "handshake"  }}
     let(:connect)     {{"channel" => "/meta/connect",     "data" => "connect"    }}
@@ -15,18 +15,18 @@ describe Faye::Server do
     let(:subscribe)   {{"channel" => "/meta/subscribe",   "data" => "subscribe"  }}
     let(:unsubscribe) {{"channel" => "/meta/unsubscribe", "data" => "unsubscribe"}}
     let(:publish)     {{"channel" => "/some/channel",     "data" => "publish"    }}
-    
+
     before do
       engine.stub(:interval).and_return(0)
       engine.stub(:timeout).and_return(60)
     end
-    
+
     it "returns an empty response for no messages" do
       response = nil
       server.process([], false) { |r| response = r }
       response.should == []
     end
-    
+
     it "ignores invalid messages" do
       response = nil
       server.process([{}, {"channel" => "invalid"}], false) { |r| response = r }
@@ -51,35 +51,35 @@ describe Faye::Server do
         }
       ]
     end
-    
+
     it "routes single messages to appropriate handlers" do
       server.should_receive(:handshake).with(handshake, false)
       server.process(handshake, false) {}
     end
-    
+
     it "routes a list of messages to appropriate handlers" do
       server.should_receive(:handshake).with(handshake, false)
       server.should_receive(:connect).with(connect, false)
       server.should_receive(:disconnect).with(disconnect, false)
       server.should_receive(:subscribe).with(subscribe, false)
       server.should_receive(:unsubscribe).with(unsubscribe, false)
-      
+
       engine.should_not_receive(:publish).with(handshake)
       engine.should_not_receive(:publish).with(connect)
       engine.should_not_receive(:publish).with(disconnect)
       engine.should_not_receive(:publish).with(subscribe)
       engine.should_not_receive(:publish).with(unsubscribe)
       engine.should_receive(:publish).with(publish)
-      
+
       server.process([handshake, connect, disconnect, subscribe, unsubscribe, publish], false)
     end
-    
+
     describe "handshaking" do
       before do
         response = {"channel" => "/meta/handshake", "successful" => true}
         server.should_receive(:handshake).with(handshake, false).and_yield(response)
       end
-      
+
       it "returns the handshake response with advice" do
         server.process(handshake, false) do |response|
           response.should == [
@@ -91,28 +91,28 @@ describe Faye::Server do
         end
       end
     end
-    
+
     describe "connecting for messages" do
       let(:messages) { [{"channel" => "/a"}, {"channel" => "/b"}] }
-      
+
       before do
         server.should_receive(:connect).with(connect, false).and_yield(messages)
       end
-      
+
       it "returns the new messages" do
         server.process(connect, false) { |r| r.should == messages }
       end
     end
   end
-  
+
   describe :flush_connection do
     let(:message) {{"clientId" => "fakeclientid"}}
-    
+
     it "flushes the connection when given one message" do
       engine.should_receive(:flush).with("fakeclientid")
       server.flush_connection(message)
     end
-    
+
     it "flushes the connection when given a list of messages" do
       engine.should_receive(:flush).with("fakeclientid")
       server.flush_connection([message])

data/spec/ruby/transport_spec.rb

@@ -4,77 +4,77 @@ describe Faye::Transport do
   before do
     Faye.ensure_reactor_running!
   end
-  
+
   let :client do
     mock("client", :endpoint => "http://example.com/", :endpoints => {}, :transports => {})
   end
-  
+
   describe :get do
     before do
       Faye::Transport::Local.stub(:usable?).and_yield(false)
       Faye::Transport::Http.stub(:usable?).and_yield(false)
     end
-    
+
     def get_transport(connection_types)
       transport = nil
-      Faye::Transport.get(client, connection_types) { |t| transport = t }
+      Faye::Transport.get(client, connection_types, []) { |t| transport = t }
       transport
     end
-    
+
     let(:transport)       { get_transport ["long-polling", "in-process"] }
     let(:local_transport) { get_transport ["in-process"] }
     let(:http_transport)  { get_transport ["long-polling"] }
-    
+
     describe "when no transport is usable" do
       it "raises an exception" do
         lambda { transport }.should raise_error
       end
     end
-    
+
     describe "when a less preferred transport is usable" do
       before do
         Faye::Transport::Http.stub(:usable?).and_yield(true)
       end
-      
+
       it "returns a transport of the usable type" do
         transport.should be_kind_of(Faye::Transport::Http)
       end
-      
+
       it "rasies an exception of the usable type is not requested" do
         lambda { local_transport }.should raise_error
       end
-      
+
       it "allows the usable type to be specifically selected" do
         http_transport.should be_kind_of(Faye::Transport::Http)
       end
     end
-    
+
     describe "when all transports are usable" do
       before do
         Faye::Transport::Local.stub(:usable?).and_yield(true)
         Faye::Transport::Http.stub(:usable?).and_yield(true)
       end
-      
+
       it "returns the most preferred type" do
         transport.should be_kind_of(Faye::Transport::Local)
       end
-      
+
       it "allows types to be specifically selected" do
         local_transport.should be_kind_of(Faye::Transport::Local)
         http_transport.should be_kind_of(Faye::Transport::Http)
       end
     end
   end
-  
+
   describe :send do
     include EM::RSpec::FakeClock
     before { clock.stub }
     after { clock.reset }
-    
+
     before do
       client.stub(:client_id).and_return("abc123")
     end
-    
+
     describe "for batching transports" do
       before do
         transport_klass = Class.new(Faye::Transport) do
@@ -84,39 +84,39 @@ describe Faye::Transport do
         end
         @transport = transport_klass.new(client, "")
       end
-      
+
       it "does not make an immediate request" do
         @transport.should_not_receive(:request)
         @transport.send({"batch" => "me"}, 60)
       end
-      
+
       it "queues the message to be sent after a timeout" do
         @transport.should_receive(:request).with([{"batch" => "me"}], 60)
         @transport.send({"batch" => "me"}, 60)
         clock.tick(0.01)
       end
-      
+
       it "allows multiple messages to be batched together" do
         @transport.should_receive(:request).with([{"id" => 1}, {"id" => 2}], 60)
         @transport.send({"id" => 1}, 60)
         @transport.send({"id" => 2}, 60)
         clock.tick(0.01)
       end
-      
+
       it "adds advice to connect messages sent with others" do
         @transport.should_receive(:request).with([{"channel" => "/meta/connect", "advice" => {"timeout" => 0}}, {}], 60)
         @transport.send({"channel" => "/meta/connect"}, 60)
         @transport.send({}, 60)
         clock.tick(0.01)
       end
-      
+
       it "adds no advice to connect messages sent alone" do
         @transport.should_receive(:request).with([{"channel" => "/meta/connect"}], 60)
         @transport.send({"channel" => "/meta/connect"}, 60)
         clock.tick(0.01)
       end
     end
-    
+
     describe "for non-batching transports" do
       before do
         transport_klass = Class.new(Faye::Transport) do
@@ -126,7 +126,7 @@ describe Faye::Transport do
         end
         @transport = transport_klass.new(client, "")
       end
-      
+
       it "makes a request immediately" do
         @transport.should_receive(:request).with([{"no" => "batch"}], 60)
         @transport.send({"no" => "batch"}, 60)