faye 0.8.8 → 0.8.9

data/spec/ruby/server/extensions_spec.rb

@@ -7,14 +7,14 @@ describe "server extensions" do
     engine.stub(:timeout).and_return(60)
     engine
   end
-  
+
   let(:server)  { Faye::Server.new }
   let(:message) { {"channel" => "/foo", "data" => "hello"} }
-  
+
   before do
     Faye::Engine.stub(:get).and_return engine
   end
-  
+
   describe "with an incoming extension installed" do
     before do
       extension = Class.new do
@@ -25,12 +25,12 @@ describe "server extensions" do
       end
       server.add_extension(extension.new)
     end
-    
+
     it "passes incoming messages through the extension" do
       engine.should_receive(:publish).with({"channel" => "/foo", "data" => "hello", "ext" => {"auth" => "password"}})
       server.process(message, false) {}
     end
-    
+
     it "does not pass outgoing messages through the extension" do
       server.stub(:handshake).and_yield(message)
       engine.stub(:publish)
@@ -39,7 +39,7 @@ describe "server extensions" do
       response.should == [{"channel" => "/foo", "data" => "hello"}]
     end
   end
-  
+
   describe "with an outgoing extension installed" do
     before do
       extension = Class.new do
@@ -50,12 +50,12 @@ describe "server extensions" do
       end
       server.add_extension(extension.new)
     end
-    
+
     it "does not pass incoming messages through the extension" do
       engine.should_receive(:publish).with({"channel" => "/foo", "data" => "hello"})
       server.process(message, false) {}
     end
-    
+
     it "passes outgoing messages through the extension" do
       server.stub(:handshake).and_yield(message)
       engine.stub(:publish)

data/spec/ruby/server/handshake_spec.rb

@@ -3,27 +3,27 @@ require "spec_helper"
 describe "server handshake" do
   let(:engine) { mock "engine" }
   let(:server) { Faye::Server.new }
-  
+
   let :connection_types do
     ["long-polling","cross-origin-long-polling","callback-polling","websocket","eventsource","in-process"]
   end
-  
+
   before do
     Faye::Engine.stub(:get).and_return engine
   end
-  
+
   describe :handshake do
     let(:message) {{"channel" => "/meta/handshake",
                     "version" => "1.0",
                     "supportedConnectionTypes" => ["long-polling"]
                   }}
-    
+
     describe "with valid parameters" do
       it "creates a client" do
         engine.should_receive(:create_client)
         server.handshake(message) {}
       end
-      
+
       it "returns a successful response" do
         engine.stub(:create_client).and_yield "clientid"
         server.handshake(message) do |response|
@@ -36,10 +36,10 @@ describe "server handshake" do
           }
         end
       end
-      
+
       describe "with a message id" do
         before { message["id"] = "foo" }
-        
+
         it "returns the same id" do
           engine.stub(:create_client).and_yield "clientid"
           server.handshake(message) do |response|
@@ -55,15 +55,15 @@ describe "server handshake" do
         end
       end
     end
-    
+
     describe "missing version" do
       before { message.delete "version" }
-      
+
       it "does not create a client" do
         engine.should_not_receive(:create_client)
         server.handshake(message) {}
       end
-      
+
       it "returns an unsuccessful response" do
         server.handshake(message) do |response|
           response.should == {
@@ -76,15 +76,15 @@ describe "server handshake" do
         end
       end
     end
-    
+
     describe "missing supportedConnectionTypes" do
       before { message.delete "supportedConnectionTypes" }
-      
+
       it "does not create a client" do
         engine.should_not_receive(:create_client)
         server.handshake(message) {}
       end
-      
+
       it "returns an unsuccessful response" do
         server.handshake(message) do |response|
           response.should == {
@@ -97,15 +97,15 @@ describe "server handshake" do
         end
       end
     end
-    
+
     describe "with no matching supportedConnectionTypes" do
       before { message["supportedConnectionTypes"] = ["iframe", "flash"] }
-      
+
       it "does not create a client" do
         engine.should_not_receive(:create_client)
         server.handshake(message) {}
       end
-      
+
       it "returns an unsuccessful response" do
         server.handshake(message) do |response|
           response.should == {
@@ -118,15 +118,15 @@ describe "server handshake" do
         end
       end
     end
-    
+
     describe "with an error" do
       before { message["error"] = "invalid" }
-      
+
       it "does not createa a client" do
         engine.should_not_receive(:create_client)
         server.handshake(message) {}
       end
-      
+
       it "returns an unsuccessful response" do
         server.handshake(message) do |response|
           response.should == {
@@ -139,5 +139,5 @@ describe "server handshake" do
         end
       end
     end
-  end  
+  end
 end

data/spec/ruby/server/integration_spec.rb

@@ -12,38 +12,38 @@ IntegrationSteps = EM::RSpec.async_steps do
       callback.call(message)
     end
   end
-  
+
   def server(port, ssl, &callback)
     shared = File.dirname(__FILE__) + '/../../../examples/shared'
-    
+
     options = ssl ?
               { :key => shared + '/server.key', :cert => shared + '/server.crt' } :
               nil
-    
+
     @adapter = Faye::RackAdapter.new(:mount => "/bayeux", :timeout => 25)
     @adapter.add_extension(Tagger.new)
     @adapter.listen(port, options)
-    
+
     @port = port
     @secure = ssl
     EM.next_tick(&callback)
   end
-  
+
   def stop(&callback)
     @adapter.stop
     EM.next_tick(&callback)
   end
-  
+
   def client(name, channels, &callback)
     scheme = @secure ? "https" : "http"
     @clients ||= {}
     @inboxes ||= {}
     @clients[name] = Faye::Client.new("#{scheme}://0.0.0.0:#{@port}/bayeux")
     @inboxes[name] = {}
-    
+
     n = channels.size
     return @clients[name].connect(&callback) if n.zero?
-    
+
     channels.each do |channel|
       subscription = @clients[name].subscribe(channel) do |message|
         @inboxes[name][channel] ||= []
@@ -55,12 +55,12 @@ IntegrationSteps = EM::RSpec.async_steps do
       end
     end
   end
-  
+
   def publish(name, channel, message, &callback)
     @clients[name].publish(channel, message)
     EM.add_timer(0.1, &callback)
   end
-  
+
   def check_inbox(name, channel, messages, &callback)
     inbox = @inboxes[name][channel] || []
     inbox.should == messages
@@ -71,63 +71,61 @@ end
 describe "server integration" do
   include IntegrationSteps
   include EncodingHelper
-  
+
   before do
-    Faye.ensure_reactor_running!
     server 8000, server_options[:ssl]
     client :alice, []
     client :bob,   ["/foo"]
-    sync
   end
-  
+
   after { stop }
-  
+
   shared_examples_for "message bus" do
     it "delivers a message between clients" do
       publish :alice, "/foo", {"hello" => "world", "extra" => nil}
       check_inbox :bob, "/foo", [{"hello" => "world", "extra" => nil, "tagged" => true}]
     end
-    
+
     it "does not deliver messages for unsubscribed channels" do
       publish :alice, "/bar", {"hello" => "world"}
       check_inbox :bob, "/foo", []
     end
-    
+
     it "delivers multiple messages" do
       publish :alice, "/foo", {"hello" => "world"}
       publish :alice, "/foo", {"hello" => "world"}
       check_inbox :bob, "/foo", [{"hello" => "world", "tagged" => true}, {"hello" => "world", "tagged" => true}]
     end
-    
+
     it "delivers multibyte strings" do
       publish :alice, "/foo", {"hello" => encode("Apple = "), "tagged" => true}
       check_inbox :bob, "/foo", [{"hello" => encode("Apple = "), "tagged" => true}]
     end
   end
-  
+
   shared_examples_for "network transports" do
     describe "with HTTP transport" do
       before do
         Faye::Transport::WebSocket.stub(:usable?).and_yield(false)
       end
-      
+
       it_should_behave_like "message bus"
     end
-    
+
     describe "with WebSocket transport" do
       before do
         Faye::Transport::WebSocket.stub(:usable?).and_yield(true)
       end
-      
+
       it_should_behave_like "message bus"
     end
   end
-  
+
   describe "with HTTP server" do
     let(:server_options) { {:ssl => false} }
     it_should_behave_like "network transports"
   end
-  
+
   describe "with HTTPS server" do
     let(:server_options) { {:ssl => true} }
     it_should_behave_like "network transports"

data/spec/ruby/server/publish_spec.rb

@@ -4,17 +4,17 @@ 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|
@@ -25,15 +25,15 @@ describe "server publish" do
         ]
       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|
@@ -46,15 +46,15 @@ describe "server publish" do
         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|

data/spec/ruby/server/subscribe_spec.rb

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