_bushido-faye 0.8.1

data/spec/javascript/server_spec.js

@@ -0,0 +1,110 @@
+JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    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"}
+      this.connect     = {channel: "/meta/connect",     data: "connect"}
+      this.disconnect  = {channel: "/meta/disconnect",  data: "disconnect"}
+      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})
+      assertEqual([
+        { successful: false,
+          error:      "405::Invalid channel"
+        },
+        { channel:    "invalid",
+          successful: false,
+          error:      "405:invalid:Invalid channel"
+        }
+      ], 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)
+      expect(engine, "publish").given(subscribe).exactly(0)
+      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([
+              { channel: "/meta/handshake",
+                successful: true,
+                advice: {reconnect: "retry", interval: 0, timeout: 60000}
+              }
+            ], response)
+        })
+      }})
+    }})
+    
+    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 )
+        })
+      }})
+    }})
+  }})
+  
+  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

@@ -0,0 +1,130 @@
+JS.ENV.TransportSpec = JS.Test.describe("Transport", function() { with(this) {
+  before(function() { with(this) {
+    this.client = {endpoint: "http://example.com/"}
+    
+    if (Faye.Transport.NodeLocal) {
+      this.LocalTransport = Faye.Transport.NodeLocal
+      this.HttpTransport  = Faye.Transport.NodeHttp
+      this.inProcess      = "in-process"
+      this.longPolling    = "long-polling"
+    } else {
+      this.LocalTransport = Faye.Transport.WebSocket
+      this.HttpTransport  = Faye.Transport.XHR
+      this.inProcess      = "websocket"
+      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]) })
+      }})
+    }})
+    
+    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) {
+          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]) })
+      }})
+      
+      it("allows the usable type to be specifically selected", function() { with(this) {
+        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) {
+          assertKindOf( LocalTransport, transport )
+        })
+      }})
+      
+      it("allows types to be specifically selected", function() { with(this) {
+        Faye.Transport.get(client, [inProcess], function(transport) {
+          assertKindOf( LocalTransport, 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

@@ -0,0 +1,55 @@
+require('jsclass')
+Faye = require('../build/faye-node')
+Faye.logger = function() {}
+
+JS.Packages(function() { with(this) {
+  autoload(/.*Spec/, {from: 'spec/javascript'})
+}})
+
+FakeSocket = function() {
+  this._fragments = []
+}
+FakeSocket.prototype.write = function(buffer, encoding) {
+  this._fragments.push([buffer, encoding])
+}
+FakeSocket.prototype.read = function() {
+  var output = []
+  this._fragments.forEach(function(buffer, i) {
+    for (var j = 0, n = buffer[0].length; j < n; j++)
+    output.push(buffer[0][j])
+  })
+  return output
+}
+FakeSocket.prototype.addListener = function() {}
+
+JS.require('Faye', 'JS.Test', 'JS.Range', function() {
+  JS.Test.Unit.Assertions.include({
+    assertYield: function(expected) {
+      var testcase = this
+      return function(actual) { testcase.assertEqual(expected, actual) }
+    }
+  })
+  
+  JS.ENV.Engine = {}
+  JS.ENV.Server = {}
+  
+  JS.require( 'FayeSpec',
+              'GrammarSpec',
+              'PublisherSpec',
+              'ChannelSpec',
+              'EngineSpec',
+              'Engine.MemorySpec',
+              'ServerSpec',
+              'Server.HandshakeSpec',
+              'Server.ConnectSpec',
+              'Server.DisconnectSpec',
+              'Server.SubscribeSpec',
+              'Server.UnsubscribeSpec',
+              'Server.PublishSpec',
+              'Server.ExtensionsSpec',
+              'Server.IntegrationSpec',
+              'NodeAdapterSpec',
+              'ClientSpec',
+              'TransportSpec',
+              JS.Test.method('autorun'))
+})

data/spec/phantom.js

@@ -0,0 +1,17 @@
+// This script should be run with PhantomJS
+// http://www.phantomjs.org/
+
+var page = new WebPage()
+
+page.onConsoleMessage = function(message) {
+  try {
+    var result = JSON.parse(message)
+    if ('total' in result && 'fail' in result) {
+      console.log(message)
+      var status = (!result.fail && !result.error) ? 0 : 1
+      phantom.exit(status)
+    }
+  } catch (e) {}
+}
+
+page.open('spec/browser.html')

data/spec/ruby/channel_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Faye::Channel do
+  describe :expand 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
+  end
+end
+

data/spec/ruby/client_spec.rb

@@ -0,0 +1,724 @@
+require "spec_helper"
+
+describe Faye::Client do
+  let :transport do
+    transport = mock("transport", :cookies= => nil, :headers= => nil)
+    transport.stub(:connection_type).and_return "fake"
+    transport.stub(:send)
+    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"]
+      @client.receive_message(response)
+    end
+  end
+
+  def create_client
+    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",
+                  "successful" => true,
+                  "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/")
+      client.state.should == :UNCONNECTED
+    end
+  end
+
+  describe :handshake do
+    before { create_client }
+
+    it "sends a handshake message to the server" do
+      transport.should_receive(:send).with({
+        "channel" => "/meta/handshake",
+        "version" => "1.0",
+        "supportedConnectionTypes" => ["fake"],
+        "id"      => instance_of(String)
+      }, 60)
+      @client.handshake
+    end
+
+    it "puts the client in the CONNECTING state" do
+      transport.stub(:send)
+      @client.handshake
+      @client.state.should == :CONNECTING
+    end
+
+    describe "with an outgoing extension installed" do
+      before do
+        extension = Class.new do
+          def outgoing(message, callback)
+            message["ext"] = {"auth" => "password"}
+            callback.call(message)
+          end
+        end
+        @client.add_extension(extension.new)
+      end
+      
+      it "passes the handshake message through the extension" do
+        transport.should_receive(:send).with({
+          "channel" => "/meta/handshake",
+          "version" => "1.0",
+          "supportedConnectionTypes" => ["fake"],
+          "id"      => instance_of(String),
+          "ext"     => {"auth" => "password"}
+        }, 60)
+        @client.handshake
+      end
+    end
+
+    describe "on successful response" do
+      before do
+        stub_response "channel"    => "/meta/handshake",
+                      "successful" => true,
+                      "version"    => "1.0",
+                      "supportedConnectionTypes" => ["long-polling", "websocket"],
+                      "clientId"   => "fakeid"
+      end
+
+      it "stores the clientId" do
+        @client.handshake
+        @client.client_id.should == "fakeid"
+      end
+
+      it "puts the client in the CONNECTED state" 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"]).
+                                             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"]).
+                                              and_return(transport)
+          @client.handshake
+        end
+      end
+    end
+
+    describe "on unsuccessful response" do
+      before do
+        stub_response "channel"    => "/meta/handshake",
+                      "successful" => false,
+                      "version"    => "1.0",
+                      "supportedConnectionTypes" => ["websocket"]
+      end
+
+      it "schedules a retry" do
+        EM.should_receive(:add_timer)
+        @client.handshake
+      end
+
+      it "puts the client in the UNCONNECTED state" do
+        EM.stub(:add_timer)
+        @client.handshake
+        @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({
+          "channel"      => "/meta/subscribe",
+          "clientId"     => "reconnectid",
+          "subscription" => "/messages/foo",
+          "id"           => instance_of(String)
+        }, 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",
+          "version" => "1.0",
+          "supportedConnectionTypes" => ["fake"],
+          "id"      => instance_of(String)
+        }, 60)
+        @client.handshake
+      end
+    end
+  end
+  
+  describe :connect do
+    describe "with an unconnected client" do
+      before do
+        stub_response "channel"    => "/meta/handshake",
+                      "successful" => true,
+                      "version"    => "1.0",
+                      "supportedConnectionTypes" => ["websocket"],
+                      "clientId"   => "handshakeid"
+        
+        create_client
+      end
+      
+      it "handshakes before connecting" do
+        transport.should_receive(:send).with({
+          "channel"        => "/meta/connect",
+          "clientId"       => "handshakeid",
+          "connectionType" => "fake",
+          "id"             => instance_of(String)
+        }, 60)
+        @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",
+          "clientId"       => "fakeid",
+          "connectionType" => "fake",
+          "id"             => instance_of(String)
+        }, 60)
+        @client.connect
+      end
+      
+      it "only opens one connect request at a time" do
+        transport.should_receive(:send).with({
+          "channel"        => "/meta/connect",
+          "clientId"       => "fakeid",
+          "connectionType" => "fake",
+          "id"             => instance_of(String)
+        }, 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({
+        "channel"  => "/meta/disconnect",
+        "clientId" => "fakeid",
+        "id"       => instance_of(String)
+      }, 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
+      @subscribe_message = {
+          "channel"      => "/meta/subscribe",
+          "clientId"     => "fakeid",
+          "subscription" => "/foo/*",
+          "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
+      it "sends multiple subscribe messages if given an array" do
+        transport.should_receive(:send).with({
+          "channel"      => "/meta/subscribe",
+          "clientId"     => "fakeid",
+          "subscription" => "/foo",
+          "id"           => instance_of(String)
+        }, 60)
+        transport.should_receive(:send).with({
+          "channel"      => "/meta/subscribe",
+          "clientId"     => "fakeid",
+          "subscription" => "/bar",
+          "id"           => instance_of(String)
+        }, 60)
+        @client.subscribe(["/foo", "/bar"])
+      end
+      
+      describe "on successful response" do
+        before do
+          stub_response "channel"      => "/meta/subscribe",
+                        "successful"   => true,
+                        "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
+              def incoming(message, callback)
+                message["data"]["changed"] = true if message["data"]
+                callback.call(message)
+              end
+            end
+            @client.add_extension(extension.new)
+            @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
+              def outgoing(message, callback)
+                message["data"]["changed"] = true if message["data"]
+                callback.call(message)
+              end
+            end
+            @client.add_extension(extension.new)
+            @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
+              def incoming(message, callback)
+                message["successful"] = false if message["channel"] == "/meta/subscribe"
+                callback.call(message)
+              end
+            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 }
+            active.should be_false
+          end
+        end
+      end
+      
+      describe "on unsuccessful response" do
+        before do
+          stub_response "channel"      => "/meta/subscribe",
+                        "error"        => "403:/meta/foo:Forbidden channel",
+                        "successful"   => false,
+                        "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 }
+          active.should be_false
+        end
+
+        it "reports the error through an errback" do
+          error = nil
+          @client.subscribe("/meta/foo").errback { |e| error = e }
+          error.code.should == 403
+          error.params.should == ["/meta/foo"]
+          error.message.should == "Forbidden channel"
+        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 }
+        active.should be_true
+      end
+    end
+  end
+  
+  describe :unsubscribe do
+    before do
+      create_connected_client
+      @unsubscribe_message = {
+          "channel"      => "/meta/unsubscribe",
+          "clientId"     => "fakeid",
+          "subscription" => "/foo/*",
+          "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)
+        @client.receive_message("channel" => "/foo/bar", "data" => "second")
+        @message.should == "first"
+      end
+    end
+    
+    describe "with multiple subscriptions to the same channel" do
+      before do
+        @messages = []
+        @hey = lambda { |m| @messages << ("hey " + m["text"]) }
+        @bye = lambda { |m| @messages << ("bye " + m["text"]) }
+        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",
+          "clientId"     => "fakeid",
+          "subscription" => "/foo",
+          "id"           => instance_of(String)
+        }, 60)
+        transport.should_receive(:send).with({
+          "channel"      => "/meta/unsubscribe",
+          "clientId"     => "fakeid",
+          "subscription" => "/bar",
+          "id"           => instance_of(String)
+        }, 60)
+        @client.unsubscribe(["/foo", "/bar"])
+      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",
+        "clientId" => "fakeid",
+        "data"     => {"hello" => "world"},
+        "id"       => instance_of(String)
+      }, 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",
+                      "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 "on receipt of the published message" do
+      before do
+        stub_response "channel"      => "/messages/foo",
+                      "data"         => {"text" => "hi"},
+                      "clientId"     => "fakeid"
+      end
+
+      it "does not trigger the callbacks" do
+        published = false
+        publication = @client.publish("/messages/foo", "text" => "hi")
+        publication.callback { published = true }
+        publication.errback { published = true }
+        published.should be_false
+      end
+    end
+
+    describe "with an outgoing extension installed" do
+      before do
+        extension = Class.new do
+          def outgoing(message, callback)
+            message["ext"] = {"auth" => "password"}
+            callback.call(message)
+          end
+        end
+        @client.add_extension(extension.new)
+      end
+      
+      it "passes messages through the extension" do
+        transport.should_receive(:send).with({
+          "channel"  => "/messages/foo",
+          "clientId" => "fakeid",
+          "data"     => {"hello" => "world"},
+          "id"       => instance_of(String),
+          "ext"      => {"auth" => "password"}
+        }, 60)
+        @client.publish("/messages/foo", "hello" => "world")
+      end
+    end
+    
+    describe "with an incoming extension installed" do
+      before do
+        extension = Class.new do
+          def incoming(message, callback)
+            message["ext"] = {"auth" => "password"}
+            callback.call(message)
+          end
+        end
+        @client.add_extension(extension.new)
+      end
+      
+      it "leaves the message unchanged" do
+        transport.should_receive(:send).with({
+          "channel"  => "/messages/foo",
+          "clientId" => "fakeid",
+          "data"     => {"hello" => "world"},
+          "id"       => instance_of(String)
+        }, 60)
+        @client.publish("/messages/foo", "hello" => "world")
+      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