faye 0.8.11 → 1.0.0

data/spec/javascript/server_spec.js

@@ -1,121 +0,0 @@
-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("rejects unknown meta channels", function() { with(this) {
-      var response = null
-      server.process([{channel: "/meta/p"}], false, function(r) { response = r })
-      assertEqual([
-        { channel:    "/meta/p",
-          successful: false,
-          error:      "403:/meta/p:Forbidden 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

@@ -1,135 +0,0 @@
-JS.ENV.TransportSpec = JS.Test.describe("Transport", function() { with(this) {
-  before(function() { with(this) {
-    this.client = {
-      endpoint:     "http://example.com/",
-      endpoints:    {},
-      transports:   {},
-      getClientId:  function() {}
-    }
-
-    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

@@ -1,55 +0,0 @@
-require('jsclass')
-Faye = require('../build/node/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

@@ -1,17 +0,0 @@
-// 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

@@ -1,17 +0,0 @@
-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

@@ -1,741 +0,0 @@
-require "spec_helper"
-
-describe Faye::Client do
-  let :transport do
-    transport = mock("transport", :cookies= => nil, :endpoint => "http://www.example.com/faye", :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 "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 "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",
-        "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", "websocket"],
-                                                    ["websocket"]).
-                                              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
-      describe "with an array of subscriptions" do
-        it "sends multiple subscribe messages" 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
-
-        it "returns an array of subscriptions" do
-          transport.stub(:send)
-          subs = @client.subscribe(["/foo", "/bar"])
-          subs.size.should == 2
-          subs.should be_all { |s| Faye::Subscription === s }
-        end
-      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
-      @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)
-      end
-    end
-  end
-end