faye 0.6.8 → 0.7.0

data/spec/ruby/client_spec.rb

@@ -5,6 +5,7 @@ describe Faye::Client do
     transport = mock("transport")
     transport.stub(:connection_type).and_return "fake"
     transport.stub(:send)
+    transport.extend(Faye::Publisher)
     transport
   end
   
@@ -18,7 +19,7 @@ describe Faye::Client do
   end
 
   def create_client
-    Faye::Transport.stub(:get).and_return(transport)
+    Faye::Transport.stub(:get).and_yield(transport)
     @client = Faye::Client.new("http://localhost/")
   end
   
@@ -106,7 +107,7 @@ describe Faye::Client do
         stub_response "channel"    => "/meta/handshake",
                       "successful" => true,
                       "version"    => "1.0",
-                      "supportedConnectionTypes" => ["websocket"],
+                      "supportedConnectionTypes" => ["long-polling", "websocket"],
                       "clientId"   => "fakeid"
       end
 
@@ -119,16 +120,26 @@ describe Faye::Client do
         @client.handshake
         @client.state.should == :CONNECTED
       end
-
+      
+      it "registers any pre-existing subscriptions" do
+        @client.should_receive(:subscribe).with([], true)
+        @client.handshake
+      end
+      
       it "selects a new transport based on what the server supports" do
-        Faye::Transport.should_receive(:get).with(instance_of(Faye::Client), ["websocket"]).
+        Faye::Transport.should_receive(:get).with(instance_of(Faye::Client), ["long-polling", "websocket"]).
                                              and_return(transport)
         @client.handshake
       end
-
-      it "registers any pre-existing subscriptions" do
-        @client.should_receive(:subscribe).with([], true)
-        @client.handshake
+      
+      describe "with websocket disabled" do
+        before { @client.disable("websocket") }
+        
+        it "selects a new transport, excluding websocket" do
+          Faye::Transport.should_receive(:get).with(instance_of(Faye::Client), ["long-polling"]).
+                                              and_return(transport)
+          @client.handshake
+        end
       end
     end
 
@@ -257,6 +268,7 @@ describe Faye::Client do
     before { create_connected_client }
     
     it "sends a disconnect message to the server" do
+      transport.stub(:close)
       transport.should_receive(:send).with({
         "channel"  => "/meta/disconnect",
         "clientId" => "fakeid",
@@ -266,9 +278,23 @@ describe Faye::Client do
     end
     
     it "puts the client in the DISCONNECTED state" do
+      transport.stub(:close)
       @client.disconnect
       @client.state.should == :DISCONNECTED
     end
+    
+    describe "on successful response" do
+      before do
+        stub_response "channel"      => "/meta/disconnect",
+                      "successful"   => true,
+                      "clientId"     => "fakeid"
+      end
+      
+      it "closes the transport" do
+        transport.should_receive(:close)
+        @client.disconnect
+      end
+    end
   end
   
   describe :subscribe do
@@ -567,6 +593,29 @@ describe Faye::Client do
       lambda { @client.publish("/messages/*", "hello" => "world") }.should raise_error
     end
     
+    describe "on publish failure" do
+      before do
+        stub_response "channel"      => "/messages/foo",
+                      "error"        => "407:/messages/foo:Failed to publish",
+                      "successful"   => false,
+                      "clientId"     => "fakeid"
+      end
+
+      it "should not be published" do
+        published = false
+        @client.publish("/messages/foo", "text" => "hi").callback { published = true }
+        published.should be_false
+      end
+
+      it "reports the error through an errback" do
+        error = nil
+        @client.publish("/messages/foo", "text" => "hi").errback { |e| error = e }
+        error.code.should == 407
+        error.params.should == ["/messages/foo"]
+        error.message.should == "Failed to publish"
+      end
+    end
+
     describe "with an outgoing extension installed" do
       before do
         extension = Class.new do
@@ -612,4 +661,48 @@ describe Faye::Client do
       end
     end
   end
+  
+  describe "network notifications" do
+    before { create_client }
+    
+    describe "in the default state" do
+      it "broadcasts a down notification" do
+        @client.should_receive(:trigger).with("transport:down")
+        transport.trigger(:down)
+      end
+      
+      it "broadcasts an up notification" do
+        @client.should_receive(:trigger).with("transport:up")
+        transport.trigger(:up)
+      end
+    end
+    
+    describe "when the transport is up" do
+      before { transport.trigger(:up) }
+      
+      it "broadcasts a down notification" do
+        @client.should_receive(:trigger).with("transport:down")
+        transport.trigger(:down)
+      end
+      
+      it "does not broadcast an up notification" do
+        @client.should_not_receive(:trigger)
+        transport.trigger(:up)
+      end
+    end
+    
+    describe "when the transport is down" do
+      before { transport.trigger(:down) }
+      
+      it "does not broadcast a down notification" do
+        @client.should_not_receive(:trigger)
+        transport.trigger(:down)
+      end
+      
+      it "broadcasts an up notification" do
+        @client.should_receive(:trigger).with("transport:up")
+        transport.trigger(:up)
+      end
+    end
+  end
 end

data/spec/ruby/engine_spec.rb

@@ -63,6 +63,12 @@ EngineSteps = EM::RSpec.async_steps do
     EM.add_timer(0.01, &resume)
   end
   
+  def publish_by(name, message, &resume)
+    message = {"clientId" => @clients[name], "id" => Faye.random}.merge(message)
+    engine.publish(message)
+    EM.add_timer(0.01, &resume)
+  end
+
   def ping(name, &resume)
     engine.ping(@clients[name])
     resume.call
@@ -73,6 +79,22 @@ EngineSteps = EM::RSpec.async_steps do
     resume.call
   end
   
+  def expect_event(name, event, args, &resume)
+    params  = [@clients[name]] + args
+    handler = lambda { |*a| }
+    engine.bind(event, &handler)
+    handler.should_receive(:call).with(*params)
+    resume.call
+  end
+
+  def expect_no_event(name, event, args, &resume)
+    params  = [@clients[name]] + args
+    handler = lambda { |*a| }
+    engine.bind(event, &handler)
+    handler.should_not_receive(:call).with(*params)
+    resume.call
+  end
+
   def expect_message(name, messages, &resume)
     @inboxes[name].should == messages
     resume.call
@@ -83,6 +105,11 @@ EngineSteps = EM::RSpec.async_steps do
     resume.call
   end
   
+  def check_different_messages(a, b, &resume)
+    @inboxes[a].first.should_not be_equal(@inboxes[b].first)
+    resume.call
+  end
+  
   def clean_redis_db(&resume)
     engine.disconnect
     redis = EM::Hiredis::Client.connect
@@ -119,6 +146,11 @@ describe "Pub/sub engines" do
         1.upto(7) { |i| create_client "client#{i}" }
         check_num_clients 10
       end
+
+      it "publishes an event" do
+        engine.should_receive(:trigger).with(:handshake, match(/^[a-z0-9]+$/)).exactly(4)
+        create_client :dave
+      end
     end
     
     describe :client_exists do
@@ -153,6 +185,11 @@ describe "Pub/sub engines" do
         check_client_exists :alice, false
       end
       
+      it "publishes an event" do
+        expect_event :alice, :disconnect, []
+        destroy_client :alice
+      end
+
       describe "when the client has subscriptions" do
         before do
           @message = {"channel" => "/messages/foo", "data" => "ok"}
@@ -165,6 +202,45 @@ describe "Pub/sub engines" do
           publish @message
           expect_no_message :alice
         end
+
+        it "publishes an event" do
+          expect_event :alice, :disconnect, []
+          destroy_client :alice
+        end
+      end
+    end
+
+    describe :subscribe do
+      it "publishes an event" do
+        expect_event :alice, :subscribe, ["/messages/foo"]
+        subscribe :alice, "/messages/foo"
+      end
+      
+      describe "when the client is subscribed to the channel" do
+        before { subscribe :alice, "/messages/foo" }
+        
+        it "does not publish an event" do
+          expect_no_event :alice, :subscribe, ["/messages/foo"]
+          subscribe :alice, "/messages/foo"
+        end
+      end
+    end
+
+    describe :unsubscribe do
+      before { subscribe :alice, "/messages/bar" }
+      
+      it "does not publish an event" do
+        expect_no_event :alice, :unsubscribe, ["/messages/foo"]
+        unsubscribe :alice, "/messages/foo"
+      end
+
+      describe "when the client is subscribed to the channel" do
+        before { subscribe :alice, "/messages/foo" }
+
+        it "publishes an event" do
+          expect_event :alice, :unsubscribe, ["/messages/foo"]
+          unsubscribe :alice, "/messages/foo"
+        end
       end
     end
     
@@ -183,6 +259,16 @@ describe "Pub/sub engines" do
           expect_no_message :bob
           expect_no_message :carol
         end
+
+        it "publishes a :publish event with a clientId" do
+          expect_event :bob, :publish, ["/messages/foo", "ok"]
+          publish_by :bob, @message
+        end
+
+        it "publishes a :publish event with no clientId" do
+          expect_event nil, :publish, ["/messages/foo", "ok"]
+          publish @message
+        end
       end
       
       describe "with a subscriber" do
@@ -198,6 +284,11 @@ describe "Pub/sub engines" do
           publish @message
           expect_message :alice, [@message]
         end
+
+        it "publishes a :publish event" do
+          expect_event :bob, :publish, ["/messages/foo", "ok"]
+          publish_by :bob, @message
+        end
       end
       
       describe "with a subscriber that is removed" do
@@ -212,6 +303,11 @@ describe "Pub/sub engines" do
           expect_no_message :bob
           expect_no_message :carol
         end
+
+        it "publishes a :publish event" do
+          expect_event :bob, :publish, ["/messages/foo", "ok"]
+          publish_by :bob, @message
+        end
       end
       
       describe "with multiple subscribers" do
@@ -257,6 +353,11 @@ describe "Pub/sub engines" do
           expect_no_message :bob
           expect_message    :carol, [@message]
         end
+        
+        it "delivers a unique copy of the message to each client" do
+          publish @message
+          check_different_messages :alice, :carol
+        end
       end
       
       describe "with multiple matching subscriptions for the same client" do
@@ -322,6 +423,11 @@ describe "Pub/sub engines" do
     after { clean_redis_db }
     it_should_behave_like "faye engine"
     it_should_behave_like "distributed engine"
+    
+    describe "using a Unix socket" do
+      before { engine_opts[:socket] = "/tmp/redis.sock" }
+      it_should_behave_like "faye engine"
+    end
   end
 end
 

data/spec/ruby/server/handshake_spec.rb

@@ -92,18 +92,6 @@ describe "server handshake" do
           }
         end
       end
-      
-      it "returns a successful response for local clients" do
-        engine.stub(:create_client).and_yield "clientid"
-        server.handshake(message, true) do |response|
-          response.should == {
-            "channel"    => "/meta/handshake",
-            "successful" => true,
-            "version"    => "1.0",
-            "clientId"   => "clientid"
-          }
-        end
-      end
     end
     
     describe "with no matching supportedConnectionTypes" do

data/spec/ruby/server/integration_spec.rb

@@ -6,10 +6,17 @@ require "thin"
 Thin::Logging.silent = true
 
 IntegrationSteps = EM::RSpec.async_steps do
-  def server(port, &callback)
+  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.listen(port)
+    @adapter.listen(port, options)
     @port = port
+    @secure = ssl
     EM.next_tick(&callback)
   end
   
@@ -19,13 +26,14 @@ IntegrationSteps = EM::RSpec.async_steps do
   end
   
   def client(name, channels, &callback)
+    scheme = @secure ? "https" : "http"
     @clients ||= {}
     @inboxes ||= {}
-    @clients[name] = Faye::Client.new("http://0.0.0.0:#{@port}/bayeux")
+    @clients[name] = Faye::Client.new("#{scheme}://0.0.0.0:#{@port}/bayeux")
     @inboxes[name] = {}
     
     n = channels.size
-    return callback.call if n.zero?
+    return @clients[name].connect(&callback) if n.zero?
     
     channels.each do |channel|
       subscription = @clients[name].subscribe(channel) do |message|
@@ -57,7 +65,7 @@ describe "server integration" do
   
   before do
     Faye.ensure_reactor_running!
-    server 8000
+    server 8000, server_options[:ssl]
     client :alice, []
     client :bob,   ["/foo"]
     sync
@@ -65,24 +73,54 @@ describe "server integration" do
   
   after { stop }
   
-  it "delivers a message between clients" do
-    publish :alice, "/foo", {"hello" => "world"}
-    check_inbox :bob, "/foo", [{"hello" => "world"}]
+  shared_examples_for "message bus" do
+    it "delivers a message between clients" do
+      publish :alice, "/foo", {"hello" => "world"}
+      check_inbox :bob, "/foo", [{"hello" => "world"}]
+    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"}, {"hello" => "world"}]
+    end
+    
+    it "delivers multibyte strings" do
+      publish :alice, "/foo", {"hello" => encode("Apple = ")}
+      check_inbox :bob, "/foo", [{"hello" => encode("Apple = ")}]
+    end
   end
   
-  it "does not deliver messages for unsubscribed channels" do
-    publish :alice, "/bar", {"hello" => "world"}
-    check_inbox :bob, "/foo", []
+  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(false)
+      end
+      
+      it_should_behave_like "message bus"
+    end
   end
   
-  it "delivers multiple messages" do
-    publish :alice, "/foo", {"hello" => "world"}
-    publish :alice, "/foo", {"hello" => "world"}
-    check_inbox :bob, "/foo", [{"hello" => "world"}, {"hello" => "world"}]
+  describe "with HTTP server" do
+    let(:server_options) { {:ssl => false} }
+    it_should_behave_like "network transports"
   end
   
-  it "delivers multibyte strings" do
-    publish :alice, "/foo", {"hello" => encode("Apple = ")}
-    check_inbox :bob, "/foo", [{"hello" => encode("Apple = ")}]
+  describe "with HTTPS server" do
+    let(:server_options) { {:ssl => true} }
+    it_should_behave_like "network transports"
   end
 end