RubyGems - faye - Versions diffs - 0.5.5 → 0.6.0 - Mend

faye 0.5.5 → 0.6.0

Potentially problematic release.

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

Files changed (62) hide show

data/History.txt +14 -0
data/README.rdoc +98 -0
data/Rakefile +17 -15
data/lib/faye-browser-min.js +1 -1
data/lib/faye.rb +14 -5
data/lib/faye/adapters/rack_adapter.rb +12 -5
data/lib/faye/engines/base.rb +62 -0
data/lib/faye/engines/connection.rb +63 -0
data/lib/faye/engines/memory.rb +89 -0
data/lib/faye/engines/redis.rb +141 -0
data/lib/faye/error.rb +16 -4
data/lib/faye/mixins/publisher.rb +6 -0
data/lib/faye/protocol/channel.rb +34 -86
data/lib/faye/protocol/client.rb +36 -52
data/lib/faye/protocol/extensible.rb +3 -0
data/lib/faye/protocol/server.rb +119 -169
data/lib/faye/transport/http.rb +45 -0
data/lib/faye/transport/local.rb +15 -0
data/lib/faye/{network → transport}/transport.rb +36 -49
data/spec/browser.html +35 -0
data/spec/install.sh +48 -0
data/spec/javascript/channel_spec.js +15 -0
data/spec/javascript/client_spec.js +610 -0
data/spec/javascript/engine_spec.js +319 -0
data/spec/javascript/faye_spec.js +15 -0
data/spec/javascript/grammar_spec.js +66 -0
data/spec/javascript/node_adapter_spec.js +276 -0
data/spec/javascript/server/connect_spec.js +168 -0
data/spec/javascript/server/disconnect_spec.js +121 -0
data/spec/javascript/server/extensions_spec.js +60 -0
data/spec/javascript/server/handshake_spec.js +153 -0
data/spec/javascript/server/subscribe_spec.js +245 -0
data/spec/javascript/server/unsubscribe_spec.js +245 -0
data/spec/javascript/server_spec.js +146 -0
data/spec/javascript/transport_spec.js +130 -0
data/spec/node.js +34 -0
data/spec/ruby/channel_spec.rb +17 -0
data/spec/ruby/client_spec.rb +615 -0
data/spec/ruby/engine_spec.rb +312 -0
data/spec/ruby/faye_spec.rb +14 -0
data/spec/ruby/grammar_spec.rb +68 -0
data/spec/ruby/rack_adapter_spec.rb +209 -0
data/spec/ruby/server/connect_spec.rb +170 -0
data/spec/ruby/server/disconnect_spec.rb +120 -0
data/spec/ruby/server/extensions_spec.rb +69 -0
data/spec/ruby/server/handshake_spec.rb +151 -0
data/spec/ruby/server/subscribe_spec.rb +247 -0
data/spec/ruby/server/unsubscribe_spec.rb +247 -0
data/spec/ruby/server_spec.rb +138 -0
data/spec/ruby/transport_spec.rb +128 -0
data/spec/spec_helper.rb +5 -0
data/spec/testswarm.pl +200 -0
data/spec/thin_proxy.rb +36 -0
metadata +119 -84
data/Manifest.txt +0 -27
data/README.txt +0 -98
data/lib/faye/protocol/connection.rb +0 -111
data/test/scenario.rb +0 -172
data/test/test_channel.rb +0 -54
data/test/test_clients.rb +0 -381
data/test/test_grammar.rb +0 -86
data/test/test_server.rb +0 -488

data/lib/faye/transport/local.rb ADDED Viewed

@@ -0,0 +1,15 @@
+module Faye
+  class Transport::Local < Transport
+    def self.usable?(endpoint)
+      endpoint.is_a?(Server)
+    end
+    def request(message, timeout)
+      @endpoint.process(message, true) { |responses| receive(responses) }
+    end
+  end
+  Transport.register 'in-process', Transport::Local
+end

data/lib/faye/{network → transport}/transport.rb RENAMED Viewed

@@ -1,4 +1,3 @@
-require 'em-http'
 require 'json'
 require 'uri'
@@ -6,21 +5,51 @@ module Faye
   class Transport
     include Logging
+    include Timeouts
     def initialize(client, endpoint)
       debug('Created new ? transport for ?', connection_type, endpoint)
-      @client    = client
-      @endpoint  = endpoint
+      @client   = client
+      @endpoint = endpoint
+      @outbox   = []
+    end
+    def batching?
+      true
     end
     def connection_type
       self.class.connection_type
     end
-    def send(messages, timeout)
-      messages = [messages].flatten
-      debug('Client ? sending message to ?: ?', @client.client_id, @endpoint, messages)
-      request(messages, timeout)
+    def send(message, timeout)
+      debug('Client ? sending message to ?: ?', @client.client_id, @endpoint, message)
+      return request([message], timeout) unless batching?
+      @outbox << message
+      @timeout = timeout
+      return flush if message['channel'] == Channel::HANDSHAKE
+      if message['channel'] == Channel::CONNECT
+        @connection_message = message
+      end
+      add_timeout(:publish, Engine::MAX_DELAY) { flush }
+    end
+    def flush
+      remove_timeout(:publish)
+      if @outbox.size > 1 and @connection_message
+        @connection_message['advice'] = {'timeout' => 0}
+      end
+      request(@outbox, @timeout)
+      @connection_message = nil
+      @outbox = []
     end
     def receive(responses)
@@ -64,49 +93,7 @@ module Faye
         @transports.map { |t| t.first }
       end
     end
-  end
-  class HttpTransport < Transport
-    def self.usable?(endpoint)
-      endpoint.is_a?(String)
-    end
-    def request(message, timeout)
-      retry_block = retry_block(message, timeout)
-      content = JSON.unparse(message)
-      params = {
-        :head => {
-          'Content-Type'    => 'application/json',
-          'host'            => URI.parse(@endpoint).host,
-          'Content-Length'  => content.length
-        },
-        :body    => content,
-        :timeout => -1
-      }
-      request = EventMachine::HttpRequest.new(@endpoint).post(params)
-      request.callback do
-        begin
-          receive(JSON.parse(request.response))
-        rescue
-          retry_block.call
-        end
-      end
-      request.errback { retry_block.call }
-    end
-  end
-  Transport.register 'long-polling', HttpTransport
-  class LocalTransport < Transport
-    def self.usable?(endpoint)
-      endpoint.is_a?(Server)
-    end
-    def request(message, timeout)
-      @endpoint.process(message, true) { |responses| receive(responses) }
-    end
   end
-  Transport.register 'in-process', LocalTransport
 end

data/spec/browser.html ADDED Viewed

@@ -0,0 +1,35 @@
+<!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="../vendor/js.class/build/min/loader.js"></script>
+  </head>
+  <body>
+    <script type="text/javascript">
+      JS.Packages(function() { with(this) {
+        file('../build/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/install.sh ADDED Viewed

@@ -0,0 +1,48 @@
+# This script installs all the necessary software to run the Ruby and
+# Node versions of Faye. Tested on Ubuntu 10.04 LTS 64-bit EC2 image:
+# http://uec-images.ubuntu.com/releases/10.04/release/
+FAYE_BRANCH=extract-engine
+NODE_VERSION=0.4.7
+REDIS_VERSION=2.2.7
+RUBY_VERSION=1.9.2
+sudo apt-get update
+sudo apt-get install build-essential g++ git-core \
+                     openssl libcurl4-openssl-dev libreadline-dev \
+                     curl wget
+bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)
+echo "source \"\$HOME/.rvm/scripts/rvm\"" | tee -a ~/.bashrc
+source ~/.rvm/scripts/rvm
+rvm install 1.9.2
+rvm --default use 1.9.2
+echo "install: --no-rdoc --no-ri
+update: --no-rdoc --no-ri" | tee ~/.gemrc
+gem install rake bundler
+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
+npm install redis
+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
+cd
+git clone git://github.com/jcoglan/faye.git
+cd faye
+git checkout $FAYE_BRANCH
+git submodule update --init --recursive
+bundle install
+cd vendor/js.class && jake
+cd ../.. && jake

data/spec/javascript/channel_spec.js ADDED Viewed

@@ -0,0 +1,15 @@
+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 ADDED Viewed

@@ -0,0 +1,610 @@
+JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
+  before(function() { with(this) {
+    this.transport = {connectionType: "fake", send: function() {}}
+    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("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])
+      new Faye.Client("http://localhost/")
+    }})
+    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("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: ["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("selects a new transport based on what the server supports", function() { with(this) {
+        expect(Faye.Transport, "get").given(instanceOf(Faye.Client), ["websocket"])
+                                     .yielding([transport])
+        client.handshake()
+      }})
+      it("registers any pre-existing subscriptions", function() { with(this) {
+        expect(client, "subscribe").given([], true)
+        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" })
+      }})
+      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) {
+      client.disconnect()
+      assertEqual( "DISCONNECTED", client.getState() )
+    }})
+  }})
+  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
+      it("sends multiple subscribe messages if given an array", 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"])
+      }})
+      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"})
+    }})
+    it("throws an error when publishing to an invalid channel", function() { with(this) {
+      expect(transport, "send").given(objectIncluding({channel: "/messages/*"}), 60).exactly(0)
+      assertThrows(Error, function() { client.publish("/messages/*", {hello: "world"}) })
+    }})
+    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"})
+      }})
+    }})
+  }})
+}})