RubyGems - faye - Versions diffs - 0.8.11 → 1.0.0 - Mend

faye 0.8.11 → 1.0.0

Potentially problematic release.

This version of faye might be problematic. Click here for more details.

Files changed (73) hide show

data/{History.txt → CHANGELOG.md} +126 -105
data/README.md +36 -0
data/lib/faye-browser-min.js +2 -1
data/lib/faye-browser-min.js.map +1 -8
data/lib/faye-browser.js +923 -607
data/lib/faye.rb +11 -5
data/lib/faye/adapters/rack_adapter.rb +80 -85
data/lib/faye/engines/connection.rb +7 -9
data/lib/faye/engines/memory.rb +1 -0
data/lib/faye/engines/proxy.rb +7 -6
data/lib/faye/mixins/deferrable.rb +15 -0
data/lib/faye/mixins/logging.rb +11 -22
data/lib/faye/mixins/publisher.rb +9 -20
data/lib/faye/protocol/channel.rb +2 -1
data/lib/faye/protocol/client.rb +70 -48
data/lib/faye/protocol/envelope.rb +24 -0
data/lib/faye/protocol/extensible.rb +7 -4
data/lib/faye/protocol/publication.rb +1 -1
data/lib/faye/protocol/server.rb +8 -11
data/lib/faye/protocol/socket.rb +6 -4
data/lib/faye/protocol/subscription.rb +1 -1
data/lib/faye/transport/http.rb +20 -27
data/lib/faye/transport/local.rb +5 -5
data/lib/faye/transport/transport.rb +42 -12
data/lib/faye/transport/web_socket.rb +71 -38
metadata +169 -137
checksums.yaml +0 -7
data/README.rdoc +0 -83
data/spec/browser.html +0 -45
data/spec/encoding_helper.rb +0 -7
data/spec/install.sh +0 -78
data/spec/javascript/channel_spec.js +0 -15
data/spec/javascript/client_spec.js +0 -729
data/spec/javascript/dispatcher_spec.js +0 -122
data/spec/javascript/engine/memory_spec.js +0 -7
data/spec/javascript/engine_spec.js +0 -417
data/spec/javascript/faye_spec.js +0 -34
data/spec/javascript/grammar_spec.js +0 -66
data/spec/javascript/node_adapter_spec.js +0 -314
data/spec/javascript/publisher_spec.js +0 -27
data/spec/javascript/server/connect_spec.js +0 -168
data/spec/javascript/server/disconnect_spec.js +0 -121
data/spec/javascript/server/extensions_spec.js +0 -60
data/spec/javascript/server/handshake_spec.js +0 -145
data/spec/javascript/server/integration_spec.js +0 -131
data/spec/javascript/server/publish_spec.js +0 -85
data/spec/javascript/server/subscribe_spec.js +0 -247
data/spec/javascript/server/unsubscribe_spec.js +0 -245
data/spec/javascript/server_spec.js +0 -121
data/spec/javascript/transport_spec.js +0 -135
data/spec/node.js +0 -55
data/spec/phantom.js +0 -17
data/spec/ruby/channel_spec.rb +0 -17
data/spec/ruby/client_spec.rb +0 -741
data/spec/ruby/engine/memory_spec.rb +0 -7
data/spec/ruby/engine_examples.rb +0 -427
data/spec/ruby/faye_spec.rb +0 -30
data/spec/ruby/grammar_spec.rb +0 -68
data/spec/ruby/publisher_spec.rb +0 -27
data/spec/ruby/rack_adapter_spec.rb +0 -241
data/spec/ruby/server/connect_spec.rb +0 -170
data/spec/ruby/server/disconnect_spec.rb +0 -120
data/spec/ruby/server/extensions_spec.rb +0 -68
data/spec/ruby/server/handshake_spec.rb +0 -143
data/spec/ruby/server/integration_spec.rb +0 -133
data/spec/ruby/server/publish_spec.rb +0 -81
data/spec/ruby/server/subscribe_spec.rb +0 -247
data/spec/ruby/server/unsubscribe_spec.rb +0 -247
data/spec/ruby/server_spec.rb +0 -121
data/spec/ruby/transport_spec.rb +0 -136
data/spec/spec_helper.rb +0 -11
data/spec/testswarm +0 -42
data/spec/thin_proxy.rb +0 -37

checksums.yaml DELETED

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: d72120c2cb19adb68d6a233bbeec413bd4ffb252
-  data.tar.gz: cea841f43962a4d522416bd526942a2d84f89c4d
-SHA512:
-  metadata.gz: 5b463e4240e2ef6df13d2964c6b3118fe26bac78efc4c9de8b18dfe6ac0454b6ee9e9fed96d4b40284528d3de132589133f25e010792355d9e3d38f382672d5c
-  data.tar.gz: ede6770eebe9be86ad5bc91bf7aefb7bd69d066cdbfa1f576ca20543ca57955267cb24967ddde658b1a362deabaa79cbbdba11603c4d3896c7e6904444bf9e01

data/README.rdoc DELETED

@@ -1,83 +0,0 @@
-= Faye
-* http://faye.jcoglan.com
-* http://groups.google.com/group/faye-users
-* http://github.com/faye/faye
-Faye is a set of tools for dirt-simple publish-subscribe messaging between web
-clients. It ships with easy-to-use message routing servers for Node.js and Rack
-applications, and clients that can be used on the server and in the browser.
-See http://faye.jcoglan.com for documentation.
-== Questions, issues, ideas
-Please raise questions on the mailing list: http://groups.google.com/group/faye-users,
-and feel free to announce and share ideas on Faye-related projects here too. I'd
-appreciate it if we only use the GitHub issue tracker for bona fide bugs; You'll
-probably get better and quicker answers to questions from the mailing list.
-== Development
-To hack on Faye, you'll need Ruby in order to build both the Gem and the NPM
-package. There are also a few submodules we use for testing. The following
-should get you up and running:
-  # Download the code from Git
-  git clone git://github.com/faye/faye.git
-  cd faye
-  git submodule update --init --recursive
-  # Install dependencies
-  bundle install
-  npm install
-  # Build Faye
-  bundle exec jake
-  # Run tests
-  bundle exec rspec -c spec/
-  node spec/node.js
-  # Install Ruby gem
-  gem build faye.gemspec
-  gem install faye-x.x.x.gem
-  # Install NPM package
-  npm install build
-== To-do
-* Provide reflection API for internal stats on channels, subscriptions, message queues
-* (Maybe) build a monitoring GUI into the server
-* Add sugar for authentication extensions for protected subscribe + publish
-* Provide support for user-defined <tt>/service/*</tt> channels
-* Let local server-side clients listen to <tt>/meta/*</tt> channels
-== License
-(The MIT License)
-Copyright (c) 2009-2013 James Coglan and contributors
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the 'Software'), to deal in
-the Software without restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/browser.html DELETED

@@ -1,45 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
-    <title>Faye test suite</title>
-    <script type="text/javascript" src="../node_modules/jsclass/min/loader.js"></script>
-  </head>
-  <body>
-    <script type="text/javascript">
-      if (typeof TestSwarm === 'undefined')
-        TestSwarm = {
-          submit: function(result) {
-            if (window.console) console.log(Faye.toJSON(result));
-          },
-          heartbeat: function() {}
-        }
-      JS.cacheBust = true
-      JS.Packages(function() { with(this) {
-        file('../build/browser/faye-browser-min.js').provides('Faye')
-        autoload(/.*Spec/, {from: './javascript'})
-      }})
-      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.require( 'FayeSpec',
-                    'GrammarSpec',
-                    'ChannelSpec',
-                    'ClientSpec',
-                    'TransportSpec',
-                    JS.Test.method('autorun'))
-      })
-    </script>
-  </body>
-</html>

data/spec/encoding_helper.rb DELETED

@@ -1,7 +0,0 @@
-module EncodingHelper
-  def encode(string)
-    return string unless string.respond_to?(:force_encoding)
-    string.force_encoding("UTF-8")
-  end
-end

data/spec/install.sh DELETED

@@ -1,78 +0,0 @@
-# This script installs all the necessary software to run the Ruby and
-# Node versions of Faye, as well as the load testing tools AB and Tsung.
-# Tested on Ubuntu 10.04 LTS 64-bit EC2 image:
-# http://uec-images.ubuntu.com/releases/10.04/release/
-FAYE_BRANCH=master
-NODE_VERSION=0.4.10
-PHANTOM_VERSION=1.2
-REDIS_VERSION=2.2.12
-RUBY_VERSION=1.9.2
-TSUNG_VERSION=1.3.3
-sudo apt-get update
-sudo apt-get install build-essential g++ git-core curl wget \
-                     openssl libcurl4-openssl-dev libreadline-dev \
-                     apache2-utils erlang gnuplot \
-                     libqt4-dev qt4-qmake xvfb
-# Install RVM and Ruby
-bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)
-echo "source \"\$HOME/.rvm/scripts/rvm\"" | tee -a ~/.bashrc
-source ~/.rvm/scripts/rvm
-rvm install $RUBY_VERSION
-rvm --default use $RUBY_VERSION
-echo "install: --no-rdoc --no-ri
-update: --no-rdoc --no-ri" | tee ~/.gemrc
-gem install rake bundler
-# Install nvm and Node
-cd ~
-git clone git://github.com/creationix/nvm.git ~/.nvm
-. ~/.nvm/nvm.sh
-echo ". ~/.nvm/nvm.sh" | tee -a ~/.bashrc
-nvm install v$NODE_VERSION
-nvm use v$NODE_VERSION
-# Install Redis from source
-cd /usr/src
-sudo wget http://redis.googlecode.com/files/redis-$REDIS_VERSION.tar.gz
-sudo tar zxvf redis-$REDIS_VERSION.tar.gz
-cd redis-$REDIS_VERSION
-sudo make
-sudo ln -s /usr/src/redis-$REDIS_VERSION/src/redis-server /usr/bin/redis-server
-sudo ln -s /usr/src/redis-$REDIS_VERSION/src/redis-cli    /usr/bin/redis-cli
-# Install PhantomJS
-cd /usr/src
-sudo git clone git://github.com/ariya/phantomjs.git
-cd phantomjs
-sudo git checkout $PHANTOM_VERSION
-sudo qmake-qt4
-sudo make
-sudo ln -s /usr/src/phantomjs/bin/phantomjs /usr/bin/phantomjs
-echo "To use phantomjs, run DISPLAY=:1 Xvfb :1 -screen 0 1024x768x16"
-# Install Tsung and required Perl modules
-cd /usr/src
-sudo wget http://tsung.erlang-projects.org/dist/tsung-$TSUNG_VERSION.tar.gz
-sudo tar zxvf tsung-$TSUNG_VERSION.tar.gz
-cd tsung-$TSUNG_VERSION
-sudo ./configure
-sudo make
-sudo make install
-sudo ln -s /usr/lib/tsung/bin/tsung_stats.pl /usr/bin/tsung-stats
-echo "To use tsung-stats you need to 'install Template' from CPAN"
-sudo perl -MCPAN -eshell
-# Check out and build Faye project
-cd ~
-git clone git://github.com/faye/faye.git
-cd faye
-git checkout $FAYE_BRANCH
-git submodule update --init --recursive
-bundle install
-npm install redis
-cd vendor/js.class && jake
-cd ../.. && jake

data/spec/javascript/channel_spec.js DELETED

@@ -1,15 +0,0 @@
-JS.ENV.ChannelSpec = JS.Test.describe("Channel", function() { with(this) {
-  describe("expand", function() { with(this) {
-    it("returns all patterns that match a channel", function() { with(this) {
-      assertEqual( ["/**", "/foo", "/*"],
-                   Faye.Channel.expand("/foo") )
-      assertEqual( ["/**", "/foo/bar", "/foo/*", "/foo/**"],
-                   Faye.Channel.expand("/foo/bar") )
-      assertEqual( ["/**", "/foo/bar/qux", "/foo/bar/*", "/foo/**", "/foo/bar/**"],
-                   Faye.Channel.expand("/foo/bar/qux") )
-    }})
-  }})
-}})

data/spec/javascript/client_spec.js DELETED

@@ -1,729 +0,0 @@
-JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
-  before(function() { with(this) {
-    this.transport = {connectionType: "fake", send: function() {}}
-    Faye.extend(transport, Faye.Publisher)
-    stub(Faye.Transport, "get").yields([transport])
-  }})
-  before(function() { with(this) {
-    stub("setTimeout")
-  }})
-  define("stubResponse", function(response) { with(this) {
-    stub(transport, "send", function(message) {
-      response.id = message.id
-      client.receiveMessage(response)
-    })
-  }})
-  define("createClient", function() { with(this) {
-    this.client = new Faye.Client("http://localhost/")
-  }})
-  define("createConnectedClient", function() { with(this) {
-    createClient()
-    stubResponse({channel:    "/meta/handshake",
-                  successful: true,
-                  version:    "1.0",
-                  supportedConnectionTypes: ["websocket"],
-                  clientId:   "fakeid" })
-    client.handshake()
-  }})
-  define("subscribe", function(client, channel, callback) { with(this) {
-    stubResponse({channel:      "/meta/subscribe",
-                  successful:   true,
-                  clientId:     "fakeid",
-                  subscription: channel })
-    this.subsCalled = 0
-    callback = callback || function() { subsCalled += 1 }
-    client.subscribe(channel, callback)
-  }})
-  describe("initialize", function() { with(this) {
-    it("puts the client in the UNCONNECTED state", function() { with(this) {
-      stub(Faye.Transport, "get")
-      var client = new Faye.Client("http://localhost/")
-      assertEqual( "UNCONNECTED", client.getState() )
-    }})
-  }})
-  describe("handshake", function() { with(this) {
-    before(function() { this.createClient() })
-   it("creates a transport the server must support", function() { with(this) {
-      expect(Faye.Transport, "get").given(instanceOf(Faye.Client),
-                                          ["long-polling", "callback-polling", "in-process"],
-                                          [])
-                                   .yielding([transport])
-      client.handshake()
-    }})
-   it("sends a handshake message to the server", function() { with(this) {
-      expect(transport, "send").given({
-        channel:  "/meta/handshake",
-        version:  "1.0",
-        supportedConnectionTypes: ["fake"],
-        id:       instanceOf("string")
-      }, 60)
-      client.handshake()
-    }})
-    it("puts the client in the CONNECTING state", function() { with(this) {
-      stub(transport, "send")
-      client.handshake()
-      assertEqual( "CONNECTING", client.getState() )
-    }})
-    describe("with an outgoing extension installed", function() { with(this) {
-      before(function() { with(this) {
-        var extension = {
-          outgoing: function(message, callback) {
-            message.ext = {auth: "password"}
-            callback(message)
-          }
-        }
-        client.addExtension(extension)
-      }})
-      it("passes the handshake message through the extension", function() { with(this) {
-        expect(transport, "send").given({
-          channel:  "/meta/handshake",
-          version:  "1.0",
-          supportedConnectionTypes: ["fake"],
-          id:       instanceOf("string"),
-          ext:      {auth: "password"}
-        }, 60)
-        client.handshake()
-      }})
-    }})
-    describe("on successful response", function() { with(this) {
-      before(function() { with(this) {
-        stubResponse({channel:    "/meta/handshake",
-                      successful: true,
-                      version:    "1.0",
-                      supportedConnectionTypes: ["long-polling", "websocket"],
-                      clientId:   "fakeid" })
-      }})
-      it("stores the clientId", function() { with(this) {
-        client.handshake()
-        assertEqual( "fakeid", client.getClientId() )
-      }})
-      it("puts the client in the CONNECTED state", function() { with(this) {
-        client.handshake()
-        assertEqual( "CONNECTED", client.getState() )
-      }})
-      it("registers any pre-existing subscriptions", function() { with(this) {
-        expect(client, "subscribe").given([], true)
-        client.handshake()
-      }})
-      it("selects a new transport based on what the server supports", function() { with(this) {
-        expect(Faye.Transport, "get").given(instanceOf(Faye.Client), ["long-polling", "websocket"], [])
-                                     .yielding([transport])
-        client.handshake()
-      }})
-      describe("with websocket disabled", function() { with(this) {
-        before(function() { this.client.disable('websocket') })
-        it("selects a new transport, excluding websocket", function() { with(this) {
-          expect(Faye.Transport, "get").given(instanceOf(Faye.Client),
-                                              ["long-polling", "websocket"],
-                                              ["websocket"])
-                                       .yielding([transport])
-          client.handshake()
-        }})
-      }})
-    }})
-    describe("on unsuccessful response", function() { with(this) {
-      before(function() { with(this) {
-        stubResponse({channel:    "/meta/handshake",
-                      successful: false,
-                      version:    "1.0",
-                      supportedConnectionTypes: ["websocket"] })
-      }})
-      it("schedules a retry", function() { with(this) {
-        expect("setTimeout")
-        client.handshake()
-      }})
-      it("puts the client in the UNCONNECTED state", function() { with(this) {
-        stub("setTimeout")
-        client.handshake()
-        assertEqual( "UNCONNECTED", client.getState() )
-      }})
-    }})
-    describe("with existing subscriptions after a server restart", function() { with(this) {
-      before(function() { with(this) {
-        createConnectedClient()
-        this.message = null
-        subscribe(client, "/messages/foo", function(m) { message = m })
-        client.receiveMessage({advice: {reconnect: "handshake"}})
-        stubResponse({channel:      "/meta/handshake",
-                      successful:   true,
-                      version:      "1.0",
-                      supportedConnectionTypes: ["websocket"],
-                      clientId:     "reconnectid",
-                      subscription: "/messages/foo" })  // tacked on to trigger subscribe() callback
-      }})
-      it("resends the subscriptions to the server", function() { with(this) {
-        expect(transport, "send").given({
-          channel:      "/meta/subscribe",
-          clientId:     "reconnectid",
-          subscription: "/messages/foo",
-          id:           instanceOf("string")
-        }, 60)
-        client.handshake()
-      }})
-      it("retains the listeners for the subscriptions", function() { with(this) {
-        client.handshake()
-        client.receiveMessage({channel: "/messages/foo", "data": "ok"})
-        assertEqual( "ok", message )
-      }})
-    }})
-    describe("with a connected client", function() { with(this) {
-      before(function() { this.createConnectedClient() })
-      it("does not send a handshake message to the server", function() { with(this) {
-        expect(transport, "send").given({
-          channel:  "/meta/handshake",
-          version:  "1.0",
-          supportedConnectionTypes: ["fake"],
-          id:       instanceOf("string")
-        }, 60)
-        .exactly(0)
-        client.handshake()
-      }})
-    }})
-  }})
-  describe("connect", function() { with(this) {
-    describe("with an unconnected client", function() { with(this) {
-      before(function() { with(this) {
-        stubResponse({channel:    "/meta/handshake",
-                      successful: true,
-                      version:    "1.0",
-                      supportedConnectionTypes: ["websocket"],
-                      clientId:   "handshakeid" })
-        createClient()
-      }})
-      it("handshakes before connecting", function() { with(this) {
-        expect(transport, "send").given({
-          channel:        "/meta/connect",
-          clientId:       "handshakeid",
-          connectionType: "fake",
-          id:             instanceOf("string")
-        }, 60)
-        client.connect()
-      }})
-    }})
-    describe("with a connected client", function() { with(this) {
-      before(function() { this.createConnectedClient() })
-      it("sends a connect message to the server", function() { with(this) {
-        expect(transport, "send").given({
-          channel:        "/meta/connect",
-          clientId:       "fakeid",
-          connectionType: "fake",
-          id:             instanceOf("string")
-        }, 60)
-        client.connect()
-      }})
-      it("only opens one connect request at a time", function() { with(this) {
-        expect(transport, "send").given({
-          channel:        "/meta/connect",
-          clientId:       "fakeid",
-          connectionType: "fake",
-          id:             instanceOf("string")
-        }, 60)
-        .exactly(1)
-        client.connect()
-        client.connect()
-      }})
-    }})
-  }})
-  describe("disconnect", function() { with(this) {
-    before(function() { this.createConnectedClient() })
-    it("sends a disconnect message to the server", function() { with(this) {
-      expect(transport, "send").given({
-        channel:  "/meta/disconnect",
-        clientId: "fakeid",
-        id:       instanceOf("string")
-      }, 60)
-      client.disconnect()
-    }})
-    it("puts the client in the DISCONNECTED state", function() { with(this) {
-      stub(transport, "close")
-      client.disconnect()
-      assertEqual( "DISCONNECTED", client.getState() )
-    }})
-    describe("on successful response", function() { with(this) {
-      before(function() { with(this) {
-        stubResponse({channel:      "/meta/disconnect",
-                      successful:   true,
-                      clientId:     "fakeid" })
-      }})
-      it("closes the transport", function() { with(this) {
-        expect(transport, "close")
-        client.disconnect()
-      }})
-    }})
-  }})
-  describe("subscribe", function() { with(this) {
-    before(function() { with(this) {
-      createConnectedClient()
-      this.subscribeMessage = {
-          channel:      "/meta/subscribe",
-          clientId:     "fakeid",
-          subscription: "/foo",
-          id:           instanceOf("string")
-        }
-    }})
-    describe("with no prior subscriptions", function() { with(this) {
-      it("sends a subscribe message to the server", function() { with(this) {
-        expect(transport, "send").given(subscribeMessage, 60)
-        client.subscribe("/foo")
-      }})
-      // 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", function() { with(this) {
-        it("sends multiple subscribe messages", function() { with(this) {
-          expect(transport, "send").given({
-            channel:      "/meta/subscribe",
-            clientId:     "fakeid",
-            subscription: "/foo",
-            id:           instanceOf("string")
-          }, 60)
-          expect(transport, "send").given({
-            channel:      "/meta/subscribe",
-            clientId:     "fakeid",
-            subscription: "/bar",
-            id:           instanceOf("string")
-          }, 60)
-          client.subscribe(["/foo", "/bar"])
-        }})
-        it("returns an array of subscriptions", function() { with(this) {
-          stub(transport, "send")
-          var subs = client.subscribe(["/foo", "/bar"])
-          assertEqual( 2, subs.length )
-          assertKindOf( Faye.Subscription, subs[0] )
-        }})
-      }})
-      describe("on successful response", function() { with(this) {
-        before(function() { with(this) {
-          stubResponse({channel:      "/meta/subscribe",
-                        successful:   true,
-                        clientId:     "fakeid",
-                        subscription: "/foo/*" })
-        }})
-        it("sets up a listener for the subscribed channel", function() { with(this) {
-          var message
-          client.subscribe("/foo/*", function(m) { message = m })
-          client.receiveMessage({channel: "/foo/bar", data: "hi"})
-          assertEqual( "hi", message )
-        }})
-        it("does not call the listener for non-matching channels", function() { with(this) {
-          var message
-          client.subscribe("/foo/*", function(m) { message = m })
-          client.receiveMessage({channel: "/bar", data: "hi"})
-          assertEqual( undefined, message )
-        }})
-        it("activates the subscription", function() { with(this) {
-          var active = false
-          client.subscribe("/foo/*").callback(function() { active = true })
-          assert( active )
-        }})
-        describe("with an incoming extension installed", function() { with(this) {
-          before(function() { with(this) {
-            var extension = {
-              incoming: function(message, callback) {
-                if (message.data) message.data.changed = true
-                callback(message)
-              }
-            }
-            client.addExtension(extension)
-            this.message = null
-            client.subscribe("/foo/*", function(m) { message = m })
-          }})
-          it("passes delivered messages through the extension", function() { with(this) {
-            client.receiveMessage({channel: "/foo/bar", data: {hello: "there"}})
-            assertEqual( {hello: "there", changed: true}, message )
-          }})
-        }})
-        describe("with an outgoing extension installed", function() { with(this) {
-          before(function() { with(this) {
-            var extension = {
-              outgoing: function(message, callback) {
-                if (message.data) message.data.changed = true
-                callback(message)
-              }
-            }
-            client.addExtension(extension)
-            this.message = null
-            client.subscribe("/foo/*", function(m) { message = m })
-          }})
-          it("leaves messages unchanged", function() { with(this) {
-            client.receiveMessage({channel: "/foo/bar", data: {hello: "there"}})
-            assertEqual( {hello: "there"}, message )
-          }})
-        }})
-        describe("with an incoming extension that invalidates the response", function() { with(this) {
-          before(function() { with(this) {
-            var extension = {
-              incoming: function(message, callback) {
-                if (message.channel === "/meta/subscribe") message.successful = false
-                callback(message)
-              }
-            }
-            client.addExtension(extension)
-          }})
-          it("does not set up a listener for the subscribed channel", function() { with(this) {
-            var message
-            client.subscribe("/foo/*", function(m) { message = m })
-            client.receiveMessage({channel: "/foo/bar", data: "hi"})
-            assertEqual( undefined, message )
-          }})
-          it("does not activate the subscription", function() { with(this) {
-            var active = false
-            client.subscribe("/foo/*").callback(function() { active = true })
-            assert( !active )
-          }})
-        }})
-      }})
-      describe("on unsuccessful response", function() { with(this) {
-        before(function() { with(this) {
-          stubResponse({channel:      "/meta/subscribe",
-                        successful:   false,
-                        error:        "403:/meta/foo:Forbidden channel",
-                        clientId:     "fakeid",
-                        subscription: "/meta/foo" })
-        }})
-        it("does not set up a listener for the subscribed channel", function() { with(this) {
-          var message
-          client.subscribe("/meta/foo", function(m) { message = m })
-          client.receiveMessage({channel: "/meta/foo", data: "hi"})
-          assertEqual( undefined, message )
-        }})
-        it("does not activate the subscription", function() { with(this) {
-          var active = false
-          client.subscribe("/meta/foo").callback(function() { active = true })
-          assert( !active )
-        }})
-        it("reports the error through an errback", function() { with(this) {
-          var error = null
-          client.subscribe("/meta/foo").errback(function(e) { error = e })
-          assertEqual( objectIncluding({code: 403, params: ["/meta/foo"], message: "Forbidden channel"}), error )
-        }})
-      }})
-    }})
-    describe("with an existing subscription", function() { with(this) {
-      before(function() { with(this) {
-        subscribe(client, "/foo/*")
-      }})
-      it("does not send another subscribe message to the server", function() { with(this) {
-        expect(transport, "send").given(subscribeMessage, 60).exactly(0)
-        client.subscribe("/foo/*")
-      }})
-      it("sets up another listener on the channel", function() { with(this) {
-        client.subscribe("/foo/*", function() { subsCalled += 1 })
-        client.receiveMessage({channel: "/foo/bar", data: "hi"})
-        assertEqual( 2, subsCalled )
-      }})
-      it("activates the subscription", function() { with(this) {
-        var active = false
-        client.subscribe("/foo/*").callback(function() { active = true })
-        assert( active )
-      }})
-    }})
-  }})
-  describe("unsubscribe", function() { with(this) {
-    before(function() { with(this) {
-      createConnectedClient()
-      this.unsubscribeMessage = {
-          channel:      "/meta/unsubscribe",
-          clientId:     "fakeid",
-          subscription: "/foo/*",
-          id:           instanceOf("string")
-        }
-    }})
-    describe("with no subscriptions", function() { with(this) {
-      it("does not send an unsubscribe message to the server", function() { with(this) {
-        expect(transport, "send").given(unsubscribeMessage, 60).exactly(0)
-        client.unsubscribe("/foo/*")
-      }})
-    }})
-    describe("with a single subscription", function() { with(this) {
-      before(function() { with(this) {
-        this.message  = null
-        this.listener = function(m) { message = m }
-        subscribe(client, "/foo/*", listener)
-      }})
-      it("sends an unsubscribe message to the server", function() { with(this) {
-        expect(transport, "send").given(unsubscribeMessage, 60)
-        client.unsubscribe("/foo/*")
-      }})
-      it("removes the listener from the channel", function() { with(this) {
-        client.receiveMessage({channel: "/foo/bar", data: "first"})
-        client.unsubscribe("/foo/*", listener)
-        client.receiveMessage({channel: "/foo/bar", data: "second"})
-        assertEqual( "first", message )
-      }})
-    }})
-    describe("with multiple subscriptions to the same channel", function() { with(this) {
-      before(function() { with(this) {
-        this.messages = []
-        this.hey = function(m) { messages.push("hey " + m.text) }
-        this.bye = function(m) { messages.push("bye " + m.text) }
-        subscribe(client, "/foo/*", hey)
-        subscribe(client, "/foo/*", bye)
-      }})
-      it("removes one of the listeners from the channel", function() { with(this) {
-        client.receiveMessage({channel: "/foo/bar", data: {text: "you"}})
-        client.unsubscribe("/foo/*", hey)
-        client.receiveMessage({channel: "/foo/bar", data: {text: "you"}})
-        assertEqual( ["hey you", "bye you", "bye you"], messages)
-      }})
-      it("does not send an unsubscribe message if one listener is removed", function() { with(this) {
-        expect(transport, "send").given(unsubscribeMessage, 60).exactly(0)
-        client.unsubscribe("/foo/*", bye)
-      }})
-      it("sends an unsubscribe message if each listener is removed", function() { with(this) {
-        expect(transport, "send").given(unsubscribeMessage, 60)
-        client.unsubscribe("/foo/*", bye)
-        client.unsubscribe("/foo/*", hey)
-      }})
-      it("sends an unsubscribe message if all listeners are removed", function() { with(this) {
-        expect(transport, "send").given(unsubscribeMessage, 60)
-        client.unsubscribe("/foo/*")
-      }})
-    }})
-    describe("with multiple subscriptions to different channels", function() { with(this) {
-      before(function() { with(this) {
-        subscribe(client, "/foo")
-        subscribe(client, "/bar")
-      }})
-      it("sends multiple unsubscribe messages if given an array", function() { with(this) {
-        expect(transport, "send").given({
-          channel:      "/meta/unsubscribe",
-          clientId:     "fakeid",
-          subscription: "/foo",
-          id:           instanceOf("string")
-        }, 60)
-        expect(transport, "send").given({
-          channel:      "/meta/unsubscribe",
-          clientId:     "fakeid",
-          subscription: "/bar",
-          id:           instanceOf("string")
-        }, 60)
-        client.unsubscribe(["/foo", "/bar"])
-      }})
-    }})
-  }})
-  describe("publish", function() { with(this) {
-    before(function() { this.createConnectedClient() })
-    it("sends the message to the server with an ID", function() { with(this) {
-      expect(transport, "send").given({
-        channel:  "/messages/foo",
-        clientId: "fakeid",
-        data:     {hello: "world"},
-        id:       instanceOf("string")
-      }, 60)
-      client.publish("/messages/foo", {hello: "world"})
-    }})
-    describe("on publish failure", function() { with(this) {
-      before(function() { with(this) {
-        stubResponse({channel:    "/messages/foo",
-                      error:      "407:/messages/foo:Failed to publish",
-                      successful: false,
-                      clientId:   "fakeid" })
-      }})
-      it("should not be published", function() { with(this) {
-        var published = false
-        client.publish("/messages/foo", {text: "hi"}).callback(function() { published = true })
-        assert( !published )
-      }})
-      it("reports the error through an errback", function() { with(this) {
-        var error = null
-        client.publish("/messages/foo", {text: "hi"}).errback(function(e) { error = e })
-        assertEqual( 407, error.code )
-        assertEqual( ["/messages/foo"], error.params )
-        assertEqual( "Failed to publish", error.message )
-      }})
-    }})
-    describe("on receipt of the published message", function() { with(this) {
-      before(function() { with(this) {
-        stubResponse({channel:    "/messages/foo",
-                      data:       {text: "hi"},
-                      clientId:   "fakeid" })
-      }})
-      it("does not trigger the callbacks", function() { with(this) {
-        var published = false
-        var publication = client.publish("/messages/foo", {text: "hi"})
-        publication.callback(function() { published = true })
-        publication.errback(function() { published = true })
-        assert( !published )
-      }})
-    }})
-    describe("with an outgoing extension installed", function() { with(this) {
-      before(function() { with(this) {
-        var extension = {
-          outgoing: function(message, callback) {
-            message.ext = {auth: "password"}
-            callback(message)
-          }
-        }
-        client.addExtension(extension)
-      }})
-      it("passes messages through the extension", function() { with(this) {
-        expect(transport, "send").given({
-          channel:  "/messages/foo",
-          clientId: "fakeid",
-          data:     {hello: "world"},
-          id:       instanceOf("string"),
-          ext:      {auth: "password"}
-        }, 60)
-        client.publish("/messages/foo", {hello: "world"})
-      }})
-    }})
-    describe("with an incoming extension installed", function() { with(this) {
-      before(function() { with(this) {
-        var extension = {
-          incoming: function(message, callback) {
-            message.ext = {auth: "password"}
-            callback(message)
-          }
-        }
-        client.addExtension(extension)
-      }})
-      it("leaves the message unchanged", function() { with(this) {
-        expect(transport, "send").given({
-          channel:  "/messages/foo",
-          clientId: "fakeid",
-          data:     {hello: "world"},
-          id:       instanceOf("string")
-        }, 60)
-        client.publish("/messages/foo", {hello: "world"})
-      }})
-    }})
-  }})
-  describe("network notifications", function() { with(this) {
-    before(function() { with(this) {
-      createClient()
-      client.handshake()
-    }})
-    describe("in the default state", function() { with(this) {
-      it("broadcasts a down notification", function() { with(this) {
-        expect(client, "trigger").given("transport:down")
-        transport.trigger("down")
-      }})
-      it("broadcasts an up notification", function() { with(this) {
-        expect(client, "trigger").given("transport:up")
-        transport.trigger("up")
-      }})
-    }})
-    describe("when the transport is up", function() { with(this) {
-      before(function() { this.transport.trigger("up") })
-      it("broadcasts a down notification", function() { with(this) {
-        expect(client, "trigger").given("transport:down")
-        transport.trigger("down")
-      }})
-      it("does not broadcast an up notification", function() { with(this) {
-        expect(client, "trigger").exactly(0)
-        transport.trigger("up")
-      }})
-    }})
-    describe("when the transport is down", function() { with(this) {
-      before(function() { this.transport.trigger("down") })
-      it("does not broadcast a down notification", function() { with(this) {
-        expect(client, "trigger").exactly(0)
-        transport.trigger("down")
-      }})
-      it("broadcasts an up notification", function() { with(this) {
-        expect(client, "trigger").given("transport:up")
-        transport.trigger("up")
-      }})
-    }})
-  }})
-}})