faye 0.8.8 → 0.8.9

data/spec/javascript/server_spec.js

@@ -4,7 +4,7 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
     stub(Faye.Engine, "get").returns(engine)
     this.server = new Faye.Server()
   }})
-  
+
   describe("#process", function() { with(this) {
     before(function() { with(this) {
       this.handshake   = {channel: "/meta/handshake",   data: "handshake"}
@@ -13,17 +13,17 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
       this.subscribe   = {channel: "/meta/subscribe",   data: "subscribe"}
       this.unsubscribe = {channel: "/meta/unsubscribe", data: "unsubscribe"}
       this.publish     = {channel: "/some/channel",     data: "publish"}
-      
+
       stub(engine, "interval", 0)
       stub(engine, "timeout", 60)
     }})
-    
+
     it("returns an empty response for no messages", function() { with(this) {
       var response = null
       server.process([], false, function(r) { response = r})
       assertEqual( [], response )
     }})
-    
+
     it("ignores invalid messages", function() { with(this) {
       var response = null
       server.process([{}, {channel: "invalid"}], false, function(r) { response = r})
@@ -48,19 +48,19 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
         }
       ], response)
     }})
-    
+
     it("routes single messages to appropriate handlers", function() { with(this) {
       expect(server, "handshake").given(handshake, false).yielding([{}])
       server.process(handshake, false, function() {})
     }})
-    
+
     it("routes a list of messages to appropriate handlers", function() { with(this) {
       expect(server, "handshake").given(handshake, false).yielding([{}])
       expect(server, "connect").given(connect, false).yielding([{}])
       expect(server, "disconnect").given(disconnect, false).yielding([{}])
       expect(server, "subscribe").given(subscribe, false).yielding([{}])
       expect(server, "unsubscribe").given(unsubscribe, false).yielding([{}])
-      
+
       expect(engine, "publish").given(handshake).exactly(0)
       expect(engine, "publish").given(connect).exactly(0)
       expect(engine, "publish").given(disconnect).exactly(0)
@@ -68,15 +68,15 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
       expect(engine, "publish").given(unsubscribe).exactly(0)
 
       expect(engine, "publish").given(publish)
-      
+
       server.process([handshake, connect, disconnect, subscribe, unsubscribe, publish], false, function() {})
     }})
-    
+
     describe("handshaking", function() { with(this) {
       before(function() { with(this) {
         expect(server, "handshake").given(handshake, false).yielding([{channel: "/meta/handshake", successful: true}])
       }})
-      
+
       it("returns the handshake response with advice", function() { with(this) {
         server.process(handshake, false, function(response) {
           assertEqual([
@@ -88,13 +88,13 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
         })
       }})
     }})
-    
+
     describe("connecting for messages", function() { with(this) {
       before(function() { with(this) {
         this.messages = [{channel: "/a"}, {channel: "/b"}]
         expect(server, "connect").given(connect, false).yielding([messages])
       }})
-      
+
       it("returns the new messages", function() { with(this) {
         server.process(connect, false, function(response) {
           assertEqual( messages, response )
@@ -102,17 +102,17 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
       }})
     }})
   }})
-  
+
   describe("#flushConnection", function() { with(this) {
     before(function() { with(this) {
       this.message = {clientId: "fakeclientid"}
     }})
-    
+
     it("flushes the connection when given one message", function() { with(this) {
       expect(engine, "flush").given("fakeclientid")
       server.flushConnection(message)
     }})
-    
+
     it("flushes the connection when given a list of messages", function() { with(this) {
       expect(engine, "flush").given("fakeclientid")
       server.flushConnection([message])

data/spec/javascript/transport_spec.js

@@ -1,7 +1,12 @@
 JS.ENV.TransportSpec = JS.Test.describe("Transport", function() { with(this) {
   before(function() { with(this) {
-    this.client = {endpoint: "http://example.com/", endpoints: {}, transports: {}}
-    
+    this.client = {
+      endpoint:     "http://example.com/",
+      endpoints:    {},
+      transports:   {},
+      getClientId:  function() {}
+    }
+
     if (Faye.Transport.NodeLocal) {
       this.LocalTransport = Faye.Transport.NodeLocal
       this.HttpTransport  = Faye.Transport.NodeHttp
@@ -14,113 +19,113 @@ JS.ENV.TransportSpec = JS.Test.describe("Transport", function() { with(this) {
       this.longPolling    = "long-polling"
     }
   }})
-  
+
   describe("get", function() { with(this) {
     before(function() { with(this) {
       stub(HttpTransport, "isUsable").yields([false])
       stub(LocalTransport, "isUsable").yields([false])
     }})
-    
+
     describe("when no transport is usable", function() { with(this) {
       it("raises an exception", function() { with(this) {
-        assertThrows(Error, function() { Faye.Transport.get(client, [longPolling, inProcess]) })
+        assertThrows(Error, function() { Faye.Transport.get(client, [longPolling, inProcess], []) })
       }})
     }})
-    
+
     describe("when a less preferred transport is usable", function() { with(this) {
       before(function() { with(this) {
         stub(HttpTransport, "isUsable").yields([true])
       }})
-      
+
       it("returns a transport of the usable type", function() { with(this) {
-        Faye.Transport.get(client, [longPolling, inProcess], function(transport) {
+        Faye.Transport.get(client, [longPolling, inProcess], [], function(transport) {
           assertKindOf( HttpTransport, transport )
         })
       }})
-      
+
       it("raises an exception if the usable type is not requested", function() { with(this) {
-        assertThrows(Error, function() { Faye.Transport.get(client, [inProcess]) })
+        assertThrows(Error, function() { Faye.Transport.get(client, [inProcess], []) })
       }})
-      
+
       it("allows the usable type to be specifically selected", function() { with(this) {
-        Faye.Transport.get(client, [longPolling], function(transport) {
+        Faye.Transport.get(client, [longPolling], [], function(transport) {
           assertKindOf( HttpTransport, transport )
         })
       }})
     }})
-    
+
     describe("when all transports are usable", function() { with(this) {
       before(function() { with(this) {
         stub(LocalTransport, "isUsable").yields([true])
         stub(HttpTransport, "isUsable").yields([true])
       }})
-      
+
       it("returns the most preferred type", function() { with(this) {
-        Faye.Transport.get(client, [longPolling, inProcess], function(transport) {
+        Faye.Transport.get(client, [longPolling, inProcess], [], function(transport) {
           assertKindOf( LocalTransport, transport )
         })
       }})
-      
+
       it("allows types to be specifically selected", function() { with(this) {
-        Faye.Transport.get(client, [inProcess], function(transport) {
+        Faye.Transport.get(client, [inProcess], [], function(transport) {
           assertKindOf( LocalTransport, transport )
         })
-        Faye.Transport.get(client, [longPolling], function(transport) {
+        Faye.Transport.get(client, [longPolling], [], function(transport) {
           assertKindOf( HttpTransport, transport )
         })
       }})
     }})
   }})
-  
+
   describe("send", function() { with(this) {
     include(JS.Test.FakeClock)
     before(function() { this.clock.stub() })
     after(function() { this.clock.reset() })
-    
+
     describe("for batching transports", function() { with(this) {
       before(function() { with(this) {
         this.Transport = Faye.Class(Faye.Transport, {batching: true})
         this.transport = new Transport(client)
       }})
-      
+
       it("does not make an immediate request", function() { with(this) {
         expect(transport, "request").exactly(0)
         transport.send({batch: "me"}, 60)
       }})
-      
+
       it("queues the message to be sent after a timeout", function() { with(this) {
         expect(transport, "request").given([{batch: "me"}], 60)
         transport.send({batch: "me"}, 60)
         clock.tick(10)
       }})
-      
+
       it("allows multiple messages to be batched together", function() { with(this) {
         expect(transport, "request").given([{id: 1}, {id: 2}], 60)
         transport.send({id: 1}, 60)
         transport.send({id: 2}, 60)
         clock.tick(10)
       }})
-      
+
       it("adds advice to connect messages sent with others", function() { with(this) {
         expect(transport, "request").given([{channel: "/meta/connect", advice: {timeout: 0}}, {}], 60)
         transport.send({channel: "/meta/connect"}, 60)
         transport.send({}, 60)
         clock.tick(10)
       }})
-      
+
       it("adds no advice to connect messages sent alone", function() { with(this) {
         expect(transport, "request").given([{channel: "/meta/connect"}], 60)
         transport.send({channel: "/meta/connect"}, 60)
         clock.tick(10)
       }})
     }})
-    
+
     describe("for non-batching transports", function() { with(this) {
       before(function() { with(this) {
         this.Transport = Faye.Class(Faye.Transport, {batching: false})
         this.transport = new Transport(client)
       }})
-      
+
       it("makes a request immediately", function() { with(this) {
         expect(transport, "request").given([{no: "batch"}], 60)
         transport.send({no: "batch"}, 60)

data/spec/node.js

@@ -29,10 +29,10 @@ JS.require('Faye', 'JS.Test', 'JS.Range', function() {
       return function(actual) { testcase.assertEqual(expected, actual) }
     }
   })
-  
+
   JS.ENV.Engine = {}
   JS.ENV.Server = {}
-  
+
   JS.require( 'FayeSpec',
               'GrammarSpec',
               'PublisherSpec',

data/spec/ruby/channel_spec.rb

@@ -5,10 +5,10 @@ describe Faye::Channel do
     it "returns all patterns that match a channel" do
       Faye::Channel.expand("/foo").should == [
                            "/**", "/foo", "/*"]
-      
+
       Faye::Channel.expand("/foo/bar").should == [
                            "/**", "/foo/bar", "/foo/*", "/foo/**"]
-      
+
       Faye::Channel.expand("/foo/bar/qux").should == [
                            "/**", "/foo/bar/qux", "/foo/bar/*", "/foo/**", "/foo/bar/**"]
     end

data/spec/ruby/client_spec.rb

@@ -8,9 +8,9 @@ describe Faye::Client do
     transport.extend(Faye::Publisher)
     transport
   end
-  
+
   before { EM.stub(:add_timer) }
-  
+
   def stub_response(response)
     transport.stub(:send) do |message, *args|
       response["id"] = message["id"]
@@ -22,7 +22,7 @@ describe Faye::Client do
     Faye::Transport.stub(:get).and_yield(transport)
     @client = Faye::Client.new("http://localhost/")
   end
-  
+
   def create_connected_client
     create_client
     stub_response "channel"    => "/meta/handshake",
@@ -30,29 +30,22 @@ describe Faye::Client do
                   "version"    => "1.0",
                   "supportedConnectionTypes" => ["websocket"],
                   "clientId"   => "fakeid"
-    
+
     @client.handshake
   end
-  
+
   def subscribe(client, channel, callback = nil)
     stub_response "channel"      => "/meta/subscribe",
                   "successful"   => true,
                   "clientId"     => "fakeid",
                   "subscription" => channel
-    
+
     @subs_called = 0
     callback ||= lambda { |m| @subs_called = 1 }
     @client.subscribe(channel, &callback)
   end
 
   describe :initialize do
-    it "creates a transport the server must support" do
-      Faye::Transport.should_receive(:get).with(instance_of(Faye::Client),
-                                                ["long-polling", "callback-polling", "in-process"]).
-                                           and_return(transport)
-      Faye::Client.new("http://localhost/")
-    end
-
     it "puts the client in the UNCONNECTED state" do
       Faye::Transport.stub(:get)
       client = Faye::Client.new("http://localhost/")
@@ -63,6 +56,14 @@ describe Faye::Client do
   describe :handshake do
     before { create_client }
 
+    it "creates a transport the server must support" do
+      Faye::Transport.should_receive(:get).with(instance_of(Faye::Client),
+                                                ["long-polling", "callback-polling", "in-process"],
+                                                []).
+                                           and_yield(transport)
+      @client.handshake
+    end
+
     it "sends a handshake message to the server" do
       transport.should_receive(:send).with({
         "channel" => "/meta/handshake",
@@ -89,7 +90,7 @@ describe Faye::Client do
         end
         @client.add_extension(extension.new)
       end
-      
+
       it "passes the handshake message through the extension" do
         transport.should_receive(:send).with({
           "channel" => "/meta/handshake",
@@ -120,23 +121,27 @@ 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), ["long-polling", "websocket"]).
+        Faye::Transport.should_receive(:get).with(instance_of(Faye::Client),
+                                                  ["long-polling", "websocket"],
+                                                  []).
                                              and_return(transport)
         @client.handshake
       end
-      
+
       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"]).
+          Faye::Transport.should_receive(:get).with(instance_of(Faye::Client),
+                                                    ["long-polling", "websocket"],
+                                                    ["websocket"]).
                                               and_return(transport)
           @client.handshake
         end
@@ -162,23 +167,23 @@ describe Faye::Client do
         @client.state.should == :UNCONNECTED
       end
     end
-    
+
     describe "with existing subscriptions after a server restart" do
       before do
         create_connected_client
-        
+
         @message = nil
         subscribe @client, "/messages/foo", lambda { |m| @message = m }
-        
+
         @client.receive_message "advice" => {"reconnect" => "handshake"}
-        
+
         stub_response "channel"    => "/meta/handshake",
                       "successful" => true,
                       "version"    => "1.0",
                       "supportedConnectionTypes" => ["websocket"],
                       "clientId"   => "reconnectid"
       end
-      
+
       it "resends the subscriptions to the server" do
         transport.should_receive(:send).with(hash_including("channel" => "/meta/handshake"), 60)
         transport.should_receive(:send).with({
@@ -189,17 +194,17 @@ describe Faye::Client do
         }, 60)
         @client.handshake
       end
-      
+
       it "retains the listeners for the subscriptions" do
         @client.handshake
         @client.receive_message("channel" => "/messages/foo", "data" => "ok")
         @message.should == "ok"
       end
     end
-    
+
     describe "with a connected client" do
       before { create_connected_client }
-      
+
       it "does not send a handshake message to the server" do
         transport.should_not_receive(:send).with({
           "channel" => "/meta/handshake",
@@ -211,7 +216,7 @@ describe Faye::Client do
       end
     end
   end
-  
+
   describe :connect do
     describe "with an unconnected client" do
       before do
@@ -220,10 +225,10 @@ describe Faye::Client do
                       "version"    => "1.0",
                       "supportedConnectionTypes" => ["websocket"],
                       "clientId"   => "handshakeid"
-        
+
         create_client
       end
-      
+
       it "handshakes before connecting" do
         transport.should_receive(:send).with({
           "channel"        => "/meta/connect",
@@ -234,10 +239,10 @@ describe Faye::Client do
         @client.connect
       end
     end
-    
+
     describe "with a connected client" do
       before { create_connected_client }
-      
+
       it "sends a connect message to the server" do
         transport.should_receive(:send).with({
           "channel"        => "/meta/connect",
@@ -247,7 +252,7 @@ describe Faye::Client do
         }, 60)
         @client.connect
       end
-      
+
       it "only opens one connect request at a time" do
         transport.should_receive(:send).with({
           "channel"        => "/meta/connect",
@@ -257,16 +262,16 @@ describe Faye::Client do
         }, 60).
         exactly(1).
         and_return # override stub implementation
-        
+
         @client.connect
         @client.connect
       end
     end
   end
-  
+
   describe :disconnect do
     before { create_connected_client }
-    
+
     it "sends a disconnect message to the server" do
       transport.stub(:close)
       transport.should_receive(:send).with({
@@ -276,27 +281,27 @@ describe Faye::Client do
       }, 60)
       @client.disconnect
     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
     before do
       create_connected_client
@@ -307,13 +312,13 @@ describe Faye::Client do
           "id"           => instance_of(String)
         }
     end
-    
+
     describe "with no prior subscriptions" do
       it "sends a subscribe message to the server" do
         transport.should_receive(:send).with(@subscribe_message, 60)
         @client.subscribe("/foo/*")
       end
-      
+
       # The Bayeux spec says the server should accept a list of subscriptions
       # in one message but the cometD server doesn't actually support this
       describe "with an array of subscriptions" do
@@ -332,7 +337,7 @@ describe Faye::Client do
           }, 60)
           @client.subscribe(["/foo", "/bar"])
         end
-        
+
         it "returns an array of subscriptions" do
           transport.stub(:send)
           subs = @client.subscribe(["/foo", "/bar"])
@@ -340,7 +345,7 @@ describe Faye::Client do
           subs.should be_all { |s| Faye::Subscription === s }
         end
       end
-      
+
       describe "on successful response" do
         before do
           stub_response "channel"      => "/meta/subscribe",
@@ -348,27 +353,27 @@ describe Faye::Client do
                         "clientId"     => "fakeid",
                         "subscription" => "/foo/*"
         end
-        
+
         it "sets up a listener for the subscribed channel" do
           @message = nil
           @client.subscribe("/foo/*") { |m| @message = m }
           @client.receive_message("channel" => "/foo/bar", "data" => "hi")
           @message.should == "hi"
         end
-        
+
         it "does not call the listener for non-matching channels" do
           @message = nil
           @client.subscribe("/foo/*") { |m| @message = m }
           @client.receive_message("channel" => "/bar", "data" => "hi")
           @message.should be_nil
         end
-        
+
         it "activates the subscription" do
           active = false
           @client.subscribe("/foo/*").callback { active = true }
           active.should be_true
         end
-        
+
         describe "with an incoming extension installed" do
           before do
             extension = Class.new do
@@ -381,13 +386,13 @@ describe Faye::Client do
             @message = nil
             @client.subscribe("/foo/*") { |m| @message = m }
           end
-          
+
           it "passes delivered messages through the extension" do
             @client.receive_message("channel" => "/foo/bar", "data" => {"hello" => "there"})
             @message.should == {"hello" => "there", "changed" => true}
           end
         end
-        
+
         describe "with an outgoing extension installed" do
           before do
             extension = Class.new do
@@ -400,13 +405,13 @@ describe Faye::Client do
             @message = nil
             @client.subscribe("/foo/*") { |m| @message = m }
           end
-          
+
           it "leaves messages unchanged" do
             @client.receive_message("channel" => "/foo/bar", "data" => {"hello" => "there"})
             @message.should == {"hello" => "there"}
           end
         end
-        
+
         describe "with an incoming extension that invalidates the response" do
           before do
             extension = Class.new do
@@ -417,14 +422,14 @@ describe Faye::Client do
             end
             @client.add_extension(extension.new)
           end
-          
+
           it "does not set up a listener for the subscribed channel" do
             @message = nil
             @client.subscribe("/foo/*") { |m| @message = m }
             @client.receive_message("channel" => "/foo/bar", "data" => "hi")
             @message.should be_nil
           end
-          
+
           it "does not activate the subscription" do
             active = false
             @client.subscribe("/foo/*").callback { active = true }
@@ -432,7 +437,7 @@ describe Faye::Client do
           end
         end
       end
-      
+
       describe "on unsuccessful response" do
         before do
           stub_response "channel"      => "/meta/subscribe",
@@ -441,14 +446,14 @@ describe Faye::Client do
                         "clientId"     => "fakeid",
                         "subscription" => "/meta/foo"
         end
-        
+
         it "does not set up a listener for the subscribed channel" do
           @message = nil
           @client.subscribe("/meta/foo") { |m| @message = m }
           @client.receive_message("channel" => "/meta/foo", "data" => "hi")
           @message.should be_nil
         end
-        
+
         it "does not activate the subscription" do
           active = false
           @client.subscribe("/meta/foo").callback { active = true }
@@ -464,23 +469,23 @@ describe Faye::Client do
         end
       end
     end
-    
+
     describe "with an existing subscription" do
       before do
         subscribe @client, "/foo/*"
       end
-      
+
       it "does not send another subscribe message to the server" do
         transport.should_not_receive(:send).with(@subscribe_message, 60)
         @client.subscribe("/foo/*")
       end
-      
+
       it "sets up another listener on the channel" do
         @client.subscribe("/foo/*") { @subs_called += 1 }
         @client.receive_message("channel" => "/foo/bar", "data" => "hi")
         @subs_called.should == 2
       end
-      
+
       it "activates the subscription" do
         active = false
         @client.subscribe("/foo/*").callback { active = true }
@@ -488,7 +493,7 @@ describe Faye::Client do
       end
     end
   end
-  
+
   describe :unsubscribe do
     before do
       create_connected_client
@@ -499,26 +504,26 @@ describe Faye::Client do
           "id"           => instance_of(String)
         }
     end
-    
+
     describe "with no subscriptions" do
       it "does not send an unsubscribe message to the server" do
         transport.should_not_receive(:send).with(@unsubscribe_message, 60)
         @client.unsubscribe("/foo/*")
       end
     end
-    
+
     describe "with a single subscription" do
       before do
         @message = nil
         @listener = lambda { |m| @message = m }
         subscribe @client, "/foo/*", @listener
       end
-      
+
       it "sends an unsubscribe message to the server" do
         transport.should_receive(:send).with(@unsubscribe_message, 60)
         @client.unsubscribe("/foo/*")
       end
-      
+
       it "removes the listener from the channel" do
         @client.receive_message("channel" => "/foo/bar", "data" => "first")
         @client.unsubscribe("/foo/*", &@listener)
@@ -526,7 +531,7 @@ describe Faye::Client do
         @message.should == "first"
       end
     end
-    
+
     describe "with multiple subscriptions to the same channel" do
       before do
         @messages = []
@@ -535,37 +540,37 @@ describe Faye::Client do
         subscribe @client, "/foo/*", @hey
         subscribe @client, "/foo/*", @bye
       end
-      
+
       it "removes one of the listeners from the channel" do
         @client.receive_message("channel" => "/foo/bar", "data" => {"text" => "you"})
         @client.unsubscribe("/foo/*", &@hey)
         @client.receive_message("channel" => "/foo/bar", "data" => {"text" => "you"})
         @messages.should == ["hey you", "bye you", "bye you"]
       end
-      
+
       it "does not send an unsubscribe message if one listener is removed" do
         transport.should_not_receive(:send).with(@unsubscribe_message, 60)
         @client.unsubscribe("/foo/*", &@bye)
       end
-      
+
       it "sends an unsubscribe message if each listener is removed" do
         transport.should_receive(:send).with(@unsubscribe_message, 60)
         @client.unsubscribe("/foo/*", &@bye)
         @client.unsubscribe("/foo/*", &@hey)
       end
-      
+
       it "sends an unsubscribe message if all listeners are removed" do
         transport.should_receive(:send).with(@unsubscribe_message, 60)
         @client.unsubscribe("/foo/*")
       end
     end
-    
+
     describe "with multiple subscriptions to different channels" do
       before do
         subscribe @client, "/foo"
         subscribe @client, "/bar"
       end
-      
+
       it "sends multiple unsubscribe messages if given an array" do
         transport.should_receive(:send).with({
           "channel"      => "/meta/unsubscribe",
@@ -583,10 +588,10 @@ describe Faye::Client do
       end
     end
   end
-  
+
   describe :publish do
     before { create_connected_client }
-    
+
     it "sends the message to the server with an ID" do
       transport.should_receive(:send).with({
         "channel"  => "/messages/foo",
@@ -596,12 +601,12 @@ describe Faye::Client do
       }, 60)
       @client.publish("/messages/foo", "hello" => "world")
     end
-    
+
     it "throws an error when publishing to an invalid channel" do
       transport.should_not_receive(:send).with(hash_including("channel" => "/messages/*"), 60)
       lambda { @client.publish("/messages/*", "hello" => "world") }.should raise_error
     end
-    
+
     describe "on publish failure" do
       before do
         stub_response "channel"      => "/messages/foo",
@@ -624,7 +629,7 @@ describe Faye::Client do
         error.message.should == "Failed to publish"
       end
     end
-    
+
     describe "on receipt of the published message" do
       before do
         stub_response "channel"      => "/messages/foo",
@@ -651,7 +656,7 @@ describe Faye::Client do
         end
         @client.add_extension(extension.new)
       end
-      
+
       it "passes messages through the extension" do
         transport.should_receive(:send).with({
           "channel"  => "/messages/foo",
@@ -663,7 +668,7 @@ describe Faye::Client do
         @client.publish("/messages/foo", "hello" => "world")
       end
     end
-    
+
     describe "with an incoming extension installed" do
       before do
         extension = Class.new do
@@ -674,7 +679,7 @@ describe Faye::Client do
         end
         @client.add_extension(extension.new)
       end
-      
+
       it "leaves the message unchanged" do
         transport.should_receive(:send).with({
           "channel"  => "/messages/foo",
@@ -686,44 +691,47 @@ describe Faye::Client do
       end
     end
   end
-  
+
   describe "network notifications" do
-    before { create_client }
-    
+    before {
+      create_client
+      @client.handshake
+    }
+
     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)