juggernaut_rails 0.5.9

data/media/juggernaut_hosts.yml

@@ -0,0 +1,18 @@
+# You should list any juggernaut hosts here.
+# You need only specify the secret key if you're using that type of authentication (see juggernaut.yml)
+# 
+# Name:                       Mapping:
+# :port                       internal push server's port
+# :host                       internal push server's host/ip
+# :public_host                public push server's host/ip (accessible from external clients)
+# :public_port                public push server's port
+# :secret_key (optional)      shared secret (should map to the key specified in the push server's config)
+# :environment (optional)     limit host to a particular RAILS_ENV
+
+:hosts:
+  - :port: 5001
+    :host: 127.0.0.1
+    :public_host: 127.0.0.1
+    :public_port: 5001
+    # :secret_key: your_secret_key
+    # :environment: :development

data/media/swfobject.js

@@ -0,0 +1,5 @@
+/*	SWFObject v2.0 <http://code.google.com/p/swfobject/>
+	Copyright (c) 2007 Geoff Stearns, Michael Williams, and Bobby van der Sluis
+	This software is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
+*/
+var swfobject=function(){var Z="undefined",P="object",B="Shockwave Flash",h="ShockwaveFlash.ShockwaveFlash",W="application/x-shockwave-flash",K="SWFObjectExprInst",G=window,g=document,N=navigator,f=[],H=[],Q=null,L=null,T=null,S=false,C=false;var a=function(){var l=typeof g.getElementById!=Z&&typeof g.getElementsByTagName!=Z&&typeof g.createElement!=Z&&typeof g.appendChild!=Z&&typeof g.replaceChild!=Z&&typeof g.removeChild!=Z&&typeof g.cloneNode!=Z,t=[0,0,0],n=null;if(typeof N.plugins!=Z&&typeof N.plugins[B]==P){n=N.plugins[B].description;if(n){n=n.replace(/^.*\s+(\S+\s+\S+$)/,"$1");t[0]=parseInt(n.replace(/^(.*)\..*$/,"$1"),10);t[1]=parseInt(n.replace(/^.*\.(.*)\s.*$/,"$1"),10);t[2]=/r/.test(n)?parseInt(n.replace(/^.*r(.*)$/,"$1"),10):0}}else{if(typeof G.ActiveXObject!=Z){var o=null,s=false;try{o=new ActiveXObject(h+".7")}catch(k){try{o=new ActiveXObject(h+".6");t=[6,0,21];o.AllowScriptAccess="always"}catch(k){if(t[0]==6){s=true}}if(!s){try{o=new ActiveXObject(h)}catch(k){}}}if(!s&&o){try{n=o.GetVariable("$version");if(n){n=n.split(" ")[1].split(",");t=[parseInt(n[0],10),parseInt(n[1],10),parseInt(n[2],10)]}}catch(k){}}}}var v=N.userAgent.toLowerCase(),j=N.platform.toLowerCase(),r=/webkit/.test(v)?parseFloat(v.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,i=false,q=j?/win/.test(j):/win/.test(v),m=j?/mac/.test(j):/mac/.test(v);/*@cc_on i=true;@if(@_win32)q=true;@elif(@_mac)m=true;@end@*/return{w3cdom:l,pv:t,webkit:r,ie:i,win:q,mac:m}}();var e=function(){if(!a.w3cdom){return }J(I);if(a.ie&&a.win){try{g.write("<script id=__ie_ondomload defer=true src=//:><\/script>");var i=c("__ie_ondomload");if(i){i.onreadystatechange=function(){if(this.readyState=="complete"){this.parentNode.removeChild(this);V()}}}}catch(j){}}if(a.webkit&&typeof g.readyState!=Z){Q=setInterval(function(){if(/loaded|complete/.test(g.readyState)){V()}},10)}if(typeof g.addEventListener!=Z){g.addEventListener("DOMContentLoaded",V,null)}M(V)}();function V(){if(S){return }if(a.ie&&a.win){var m=Y("span");try{var l=g.getElementsByTagName("body")[0].appendChild(m);l.parentNode.removeChild(l)}catch(n){return }}S=true;if(Q){clearInterval(Q);Q=null}var j=f.length;for(var k=0;k<j;k++){f[k]()}}function J(i){if(S){i()}else{f[f.length]=i}}function M(j){if(typeof G.addEventListener!=Z){G.addEventListener("load",j,false)}else{if(typeof g.addEventListener!=Z){g.addEventListener("load",j,false)}else{if(typeof G.attachEvent!=Z){G.attachEvent("onload",j)}else{if(typeof G.onload=="function"){var i=G.onload;G.onload=function(){i();j()}}else{G.onload=j}}}}}function I(){var l=H.length;for(var j=0;j<l;j++){var m=H[j].id;if(a.pv[0]>0){var k=c(m);if(k){H[j].width=k.getAttribute("width")?k.getAttribute("width"):"0";H[j].height=k.getAttribute("height")?k.getAttribute("height"):"0";if(O(H[j].swfVersion)){if(a.webkit&&a.webkit<312){U(k)}X(m,true)}else{if(H[j].expressInstall&&!C&&O("6.0.65")&&(a.win||a.mac)){D(H[j])}else{d(k)}}}}else{X(m,true)}}}function U(m){var k=m.getElementsByTagName(P)[0];if(k){var p=Y("embed"),r=k.attributes;if(r){var o=r.length;for(var n=0;n<o;n++){if(r[n].nodeName.toLowerCase()=="data"){p.setAttribute("src",r[n].nodeValue)}else{p.setAttribute(r[n].nodeName,r[n].nodeValue)}}}var q=k.childNodes;if(q){var s=q.length;for(var l=0;l<s;l++){if(q[l].nodeType==1&&q[l].nodeName.toLowerCase()=="param"){p.setAttribute(q[l].getAttribute("name"),q[l].getAttribute("value"))}}}m.parentNode.replaceChild(p,m)}}function F(i){if(a.ie&&a.win&&O("8.0.0")){G.attachEvent("onunload",function(){var k=c(i);if(k){for(var j in k){if(typeof k[j]=="function"){k[j]=function(){}}}k.parentNode.removeChild(k)}})}}function D(j){C=true;var o=c(j.id);if(o){if(j.altContentId){var l=c(j.altContentId);if(l){L=l;T=j.altContentId}}else{L=b(o)}if(!(/%$/.test(j.width))&&parseInt(j.width,10)<310){j.width="310"}if(!(/%$/.test(j.height))&&parseInt(j.height,10)<137){j.height="137"}g.title=g.title.slice(0,47)+" - Flash Player Installation";var n=a.ie&&a.win?"ActiveX":"PlugIn",k=g.title,m="MMredirectURL="+G.location+"&MMplayerType="+n+"&MMdoctitle="+k,p=j.id;if(a.ie&&a.win&&o.readyState!=4){var i=Y("div");p+="SWFObjectNew";i.setAttribute("id",p);o.parentNode.insertBefore(i,o);o.style.display="none";G.attachEvent("onload",function(){o.parentNode.removeChild(o)})}R({data:j.expressInstall,id:K,width:j.width,height:j.height},{flashvars:m},p)}}function d(j){if(a.ie&&a.win&&j.readyState!=4){var i=Y("div");j.parentNode.insertBefore(i,j);i.parentNode.replaceChild(b(j),i);j.style.display="none";G.attachEvent("onload",function(){j.parentNode.removeChild(j)})}else{j.parentNode.replaceChild(b(j),j)}}function b(n){var m=Y("div");if(a.win&&a.ie){m.innerHTML=n.innerHTML}else{var k=n.getElementsByTagName(P)[0];if(k){var o=k.childNodes;if(o){var j=o.length;for(var l=0;l<j;l++){if(!(o[l].nodeType==1&&o[l].nodeName.toLowerCase()=="param")&&!(o[l].nodeType==8)){m.appendChild(o[l].cloneNode(true))}}}}}return m}function R(AE,AC,q){var p,t=c(q);if(typeof AE.id==Z){AE.id=q}if(a.ie&&a.win){var AD="";for(var z in AE){if(AE[z]!=Object.prototype[z]){if(z=="data"){AC.movie=AE[z]}else{if(z.toLowerCase()=="styleclass"){AD+=' class="'+AE[z]+'"'}else{if(z!="classid"){AD+=" "+z+'="'+AE[z]+'"'}}}}}var AB="";for(var y in AC){if(AC[y]!=Object.prototype[y]){AB+='<param name="'+y+'" value="'+AC[y]+'" />'}}t.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+AD+">"+AB+"</object>";F(AE.id);p=c(AE.id)}else{if(a.webkit&&a.webkit<312){var AA=Y("embed");AA.setAttribute("type",W);for(var x in AE){if(AE[x]!=Object.prototype[x]){if(x=="data"){AA.setAttribute("src",AE[x])}else{if(x.toLowerCase()=="styleclass"){AA.setAttribute("class",AE[x])}else{if(x!="classid"){AA.setAttribute(x,AE[x])}}}}}for(var w in AC){if(AC[w]!=Object.prototype[w]){if(w!="movie"){AA.setAttribute(w,AC[w])}}}t.parentNode.replaceChild(AA,t);p=AA}else{var s=Y(P);s.setAttribute("type",W);for(var v in AE){if(AE[v]!=Object.prototype[v]){if(v.toLowerCase()=="styleclass"){s.setAttribute("class",AE[v])}else{if(v!="classid"){s.setAttribute(v,AE[v])}}}}for(var u in AC){if(AC[u]!=Object.prototype[u]&&u!="movie"){E(s,u,AC[u])}}t.parentNode.replaceChild(s,t);p=s}}return p}function E(k,i,j){var l=Y("param");l.setAttribute("name",i);l.setAttribute("value",j);k.appendChild(l)}function c(i){return g.getElementById(i)}function Y(i){return g.createElement(i)}function O(k){var j=a.pv,i=k.split(".");i[0]=parseInt(i[0],10);i[1]=parseInt(i[1],10);i[2]=parseInt(i[2],10);return(j[0]>i[0]||(j[0]==i[0]&&j[1]>i[1])||(j[0]==i[0]&&j[1]==i[1]&&j[2]>=i[2]))?true:false}function A(m,j){if(a.ie&&a.mac){return }var l=g.getElementsByTagName("head")[0],k=Y("style");k.setAttribute("type","text/css");k.setAttribute("media","screen");if(!(a.ie&&a.win)&&typeof g.createTextNode!=Z){k.appendChild(g.createTextNode(m+" {"+j+"}"))}l.appendChild(k);if(a.ie&&a.win&&typeof g.styleSheets!=Z&&g.styleSheets.length>0){var i=g.styleSheets[g.styleSheets.length-1];if(typeof i.addRule==P){i.addRule(m,j)}}}function X(k,i){var j=i?"visible":"hidden";if(S){c(k).style.visibility=j}else{A("#"+k,"visibility:"+j)}}return{registerObject:function(l,i,k){if(!a.w3cdom||!l||!i){return }var j={};j.id=l;j.swfVersion=i;j.expressInstall=k?k:false;H[H.length]=j;X(l,false)},getObjectById:function(l){var i=null;if(a.w3cdom&&S){var j=c(l);if(j){var k=j.getElementsByTagName(P)[0];if(!k||(k&&typeof j.SetVariable!=Z)){i=j}else{if(typeof k.SetVariable!=Z){i=k}}}}return i},embedSWF:function(n,u,r,t,j,m,k,p,s){if(!a.w3cdom||!n||!u||!r||!t||!j){return }r+="";t+="";if(O(j)){X(u,false);var q=(typeof s==P)?s:{};q.data=n;q.width=r;q.height=t;var o=(typeof p==P)?p:{};if(typeof k==P){for(var l in k){if(k[l]!=Object.prototype[l]){if(typeof o.flashvars!=Z){o.flashvars+="&"+l+"="+k[l]}else{o.flashvars=l+"="+k[l]}}}}J(function(){R(q,o,u);if(q.id==u){X(u,true)}})}else{if(m&&!C&&O("6.0.65")&&(a.win||a.mac)){X(u,false);J(function(){var i={};i.id=i.altContentId=u;i.width=r;i.height=t;i.expressInstall=m;D(i)})}}},getFlashPlayerVersion:function(){return{major:a.pv[0],minor:a.pv[1],release:a.pv[2]}},hasFlashPlayerVersion:O,createSWF:function(k,j,i){if(a.w3cdom&&S){return R(k,j,i)}else{return undefined}},createCSS:function(j,i){if(a.w3cdom){A(j,i)}},addDomLoadEvent:J,addLoadEvent:M,getQueryParamValue:function(m){var l=g.location.search||g.location.hash;if(m==null){return l}if(l){var k=l.substring(1).split("&");for(var j=0;j<k.length;j++){if(k[j].substring(0,k[j].indexOf("="))==m){return k[j].substring((k[j].indexOf("=")+1))}}}return""},expressInstallCallback:function(){if(C&&L){var i=c(K);if(i){i.parentNode.replaceChild(L,i);if(T){X(T,true);if(a.ie&&a.win){L.style.display="block"}}L=null;T=null;C=false}}}}}();

data/rails/init.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), '../lib/juggernaut')
+require File.join(File.dirname(__FILE__), '../lib/juggernaut/rails')
+require File.join(File.dirname(__FILE__), '../lib/juggernaut/rails/helpers')
+
+Juggernaut.send(:include, Juggernaut::Rails::ConvenienceMethods)
+ActionView::Base.send(:include, Juggernaut::Rails::Helpers)
+
+ActionView::Helpers::AssetTagHelper.register_javascript_expansion :juggernaut => ['juggernaut/swfobject', 'juggernaut/juggernaut']
+ActionView::Helpers::AssetTagHelper.register_javascript_expansion :juggernaut_jquery => ['juggernaut/json', 'juggernaut/juggernaut', 'juggernaut/jquerynaut', 'juggernaut/swfobject']
+
+ActionController::Base.class_eval do
+  alias_method :render_without_juggernaut, :render
+  include Juggernaut::Rails::RenderExtension
+  alias_method :render, :render_with_juggernaut
+end
+
+ActionView::Base.class_eval do
+  alias_method :render_without_juggernaut, :render
+  include Juggernaut::Rails::RenderExtension
+  alias_method :render, :render_with_juggernaut
+end

data/test/test_client.rb

@@ -0,0 +1,176 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestClient < Test::Unit::TestCase
+  
+  CONFIG = File.join(File.dirname(__FILE__), "files", "juggernaut.yml")
+  
+  class DummySubscriber; end
+  
+  EXAMPLE_URL = "http://localhost:5000/callbacks/example"
+  SECURE_URL = "https://localhost:5000/callbacks/example"
+  
+  context "Client" do
+    
+    setup do
+      Juggernaut.options = {
+        :logout_connection_url => "http://localhost:5000/callbacks/logout_connection",
+        :logout_url => "http://localhost:5000/callbacks/logout",
+        :subscription_url => "http://localhost:5000/callbacks/subscription"
+      }
+      @s1 = DummySubscriber.new
+      @request = {
+        :client_id => "jonny",
+        :session_id => rand(1_000_000).to_s(16)
+      }
+      @client = Juggernaut::Client.find_or_create(@s1, @request)
+    end
+    
+    teardown do
+      Juggernaut::Client.reset!
+    end
+    
+    should "have correct JSON representation" do
+      assert_nothing_raised do
+        json = {
+          "client_id"  => "jonny",
+          "num_connections" => 1,
+          "session_id" => @request[:session_id]
+        }
+        assert_equal json, JSON.parse(@client.to_json)
+      end
+    end
+    
+    should "return the client based on subscriber's signature" do
+      @s1.stubs(:signature).returns("012345")
+      assert_equal @client, Juggernaut::Client.find_by_signature("012345")
+    end
+    
+    should "return the client based on client ID and channel list" do
+      @client.stubs(:has_channels?).with(%w(a couple of channels)).returns(true)
+      assert_equal @client, Juggernaut::Client.find_by_id_and_channels("jonny", %w(a couple of channels))
+      assert_nil Juggernaut::Client.find_by_id_and_channels("peter", %w(a couple of channels))
+      @client.stubs(:has_channels?).with(%w(something else)).returns(false)
+      assert_nil Juggernaut::Client.find_by_id_and_channels("jonny", %w(something else))
+    end
+    
+    should "automatically be registered, and can unregister" do
+      assert @client.send(:registered?)
+      assert_equal @client, @client.send(:unregister)
+      assert_equal false, @client.send(:registered?)
+    end
+    
+    should "be alive if at least one subscriber is alive" do
+      @s1.stubs(:alive?).returns(true)
+      @s2 = DummySubscriber.new
+      @client.add_new_connection(@s2)
+      @s2.stubs(:alive?).returns(false)
+      assert @client.alive?
+    end
+    
+    should "not be alive if no subscriber is alive" do
+      @s1.stubs(:alive?).returns(false)
+      @s2 = DummySubscriber.new
+      @client.add_new_connection(@s2)
+      @s2.stubs(:alive?).returns(false)
+      assert_equal false, @client.alive?
+    end
+
+    should "not give up if within the timeout period" do
+      Juggernaut.options[:timeout] = 10
+      @s1.stubs(:alive?).returns(false)
+      @client.send(:reset_logout_timeout!)
+      assert_equal false, @client.give_up?
+    end
+
+    should "not give up if at least one subscriber is alive" do
+      Juggernaut.options[:timeout] = 0
+      @s1.stubs(:alive?).returns(true)
+      @client.send(:reset_logout_timeout!)
+      assert_equal false, @client.give_up?
+    end
+    
+    should "send logouts after timeout" do
+      Juggernaut.options[:timeout] = 0
+      @s1.stubs(:alive?).returns(false)
+      @client.send(:reset_logout_timeout!)
+      @client.expects(:logout_request).once
+      Juggernaut::Client.send_logouts_after_timeout
+    end
+    
+    %w(subscription logout_connection).each do |type|
+      
+      context "#{type} request" do
+        
+        should "post to the correct URL" do
+          @client.expects(:post_request).with(Juggernaut.options[:"#{type}_url"], %w(master), :timeout => 5).returns(true)
+          assert_equal true, @client.send("#{type}_request", %w(master))
+        end
+        
+        should "not raise exceptions if posting raises an exception" do
+          @client.expects(:post_request).with(Juggernaut.options[:"#{type}_url"], %w(master), :timeout => 5).returns(false)
+          assert_nothing_raised {
+            assert_equal false, @client.send("#{type}_request", %w(master))
+          }
+        end
+        
+      end
+      
+    end
+    
+    context "post to URL" do
+      
+      should "return true when successful" do
+        Net::HTTP.any_instance.
+          expects(:post).
+          with("/callbacks/example", "client_id=jonny&session_id=#{@request[:session_id]}&channels[]=master&channels[]=slave", {"User-Agent" => "Ruby/#{RUBY_VERSION}"}).
+          returns([Net::HTTPOK.new('1.1', '200', 'OK'), ''])
+        assert_equal true, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      should "return false on an internal server error" do
+        Net::HTTP.any_instance.expects(:post).returns([Net::HTTPInternalServerError.new('1.1', '500', 'Internal Server Error'), ''])
+        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      should "return false when a runtime error is caught" do
+        Net::HTTP.any_instance.expects(:post).raises(RuntimeError)
+        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      should "return false when callback times out" do
+        Net::HTTP.any_instance.expects(:post).raises(Timeout::Error)
+        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      context "using a secure URL" do
+        
+        should "return true when successful" do
+          Net::HTTP.any_instance.expects(:post).returns([Net::HTTPOK.new('1.1', '200', 'OK'), ''])
+          Net::HTTP.any_instance.expects(:use_ssl=).with(true).returns(true)
+          assert_equal true, @client.send(:post_request, SECURE_URL, %w(master slave))
+        end
+        
+      end
+      
+    end
+    
+    context "channel list" do
+      
+      should "be the unique list of all channels in the subscribers" do
+        @s1.stubs(:channels).returns(%w(master slave1))
+        @s2 = DummySubscriber.new
+        @s2.stubs(:channels).returns(%w(master slave2))
+        @client.add_new_connection(@s2)
+        assert_same_elements %w(master slave1 slave2), @client.channels
+      end
+      
+    end
+    
+  end
+  
+end

data/test/test_juggernaut.rb

@@ -0,0 +1,34 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestJuggernaut < Test::Unit::TestCase
+  
+  context "Juggernaut" do
+    
+    setup do
+      Juggernaut.options = { }
+    end
+    
+    should "set options correctly" do
+      options = {
+        :host => "0.0.0.0",
+        :port => 5001,
+        :debug => false
+      }
+      Juggernaut.options = options
+      assert_equal options, Juggernaut.options
+    end
+    
+    should "have a debug logger by default" do
+      log = Juggernaut.logger
+      assert_not_nil log
+      assert_equal Logger::DEBUG, log.level
+    end
+    
+  end
+  
+end

data/test/test_message.rb

@@ -0,0 +1,26 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestMessage < Test::Unit::TestCase
+  
+  context "Message" do
+    
+    setup do
+      @msg = Juggernaut::Message.new(1, "A pre-determined message body", "a81fef13919")
+      assert_not_nil @msg
+    end
+    
+    should "generate valid JSON" do
+      obj = {"signature" => "a81fef13919", "body" => "A pre-determined message body", "id" => "1"}
+      assert_nothing_raised do
+        assert_equal obj, JSON.parse(@msg.to_s)
+      end
+    end
+    
+  end
+  
+end

data/test/test_runner.rb

@@ -0,0 +1,26 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+require "tempfile"
+
+class TestRunner < Test::Unit::TestCase
+  
+  CONFIG = File.join(File.dirname(__FILE__), "files", "juggernaut.yml")
+  
+  context "Runner" do
+    
+    should "always be true" do
+      assert true
+    end
+    
+    # should "run" do
+    #   EM.run { EM.stop }
+    #   Juggernaut::Runner.run(["-c", CONFIG])
+    # end
+    
+  end
+  
+end

data/test/test_server.rb

@@ -0,0 +1,573 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestServer < Test::Unit::TestCase
+  
+  CONFIG = File.join(File.dirname(__FILE__), "files", "juggernaut.yml")
+  
+  DEFAULT_OPTIONS = {
+    :host => "0.0.0.0",
+    :port => 5001,
+    :debug => false,
+    :cleanup_timer => 2,
+    :timeout => 10,
+    :store_messages => false
+  }
+  
+  OPTIONS = DEFAULT_OPTIONS.merge(YAML::load(ERB.new(IO.read(CONFIG)).result))
+  
+  class DirectClient
+    attr_reader :channels
+    def broadcast_to_channels(channels, body)
+      self.transmit :command => :broadcast, :type => :to_channels, :channels => channels, :body => body
+      self
+    end
+    def broadcast_to_clients(clients, body)
+      self.transmit :command => :broadcast, :type => :to_clients, :client_ids => clients, :body => body
+    end
+    def close
+      @socket.close if @socket
+    end
+    def initialize(options)
+      @options = options
+      @socket = nil
+      @client_id = options[:client_id]
+      @session_id = options[:session_id] || rand(1_000_000).to_s(16)
+      @channels = [ ]
+      @socket = TCPSocket.new(@options[:host], @options[:port])
+    end
+    def inspect
+      {:channels => @channels, :client_id => @client_id, :session_id => @session_id}.inspect
+    end
+    def request_crossdomain_file
+      @socket.print "<policy-file-request/>\0"
+      self
+    end
+    def query_remove_channels_from_all_clients(channels)
+      self.transmit :command => :query, :type => :remove_channels_from_all_clients, :channels => channels
+      self
+    end
+    def query_remove_channels_from_client(channels, clients)
+      self.transmit :command => :query, :type => :remove_channels_from_client, :client_ids => clients, :channels => channels
+      self
+    end
+    def query_show_channels_for_client(client_id)
+      self.transmit :command => :query, :type => :show_channels_for_client, :client_id => client_id
+      self
+    end
+    def query_show_client(client_id)
+      self.transmit :command => :query, :type => :show_client, :client_id => client_id
+      self
+    end
+    def query_show_clients(client_ids = [])
+      self.transmit :command => :query, :type => :show_clients, :client_ids => client_ids
+      self
+    end
+    def query_show_clients_for_channels(channels)
+      self.transmit :command => :query, :type => :show_clients_for_channels, :channels => channels
+      self
+    end
+    def receive(as_json = true)
+      return nil unless @socket
+      begin
+        # response = @socket.read.to_s
+        # response = @socket.readline("\0").to_s
+        response = ""
+        begin
+          response << @socket.read_nonblock(1024)
+        rescue Errno::EAGAIN
+        end
+        response.chomp!("\0")
+        Juggernaut.logger.info "DirectClient read: " + response.inspect
+        as_json ? JSON.parse(response) : response
+      rescue => e
+        Juggernaut.logger.error "DirectClient #{e.class}: #{e.message}"
+        raise
+      end
+    end
+    def subscribe(channels)
+      channels.each do |channel|
+        @channels << channel.to_s unless @channels.include?(channel.to_s)
+      end
+      self.transmit :command => :subscribe, :channels => channels
+      self
+    end
+    def send_raw(raw, wait_response = false)
+      @socket.print(raw + "\0")
+      @socket.flush
+      if wait_response
+        self.receive
+      else
+        nil
+      end
+    end
+    def transmit(hash, wait_response = false)
+      hash[:client_id] ||= @client_id
+      hash[:session_id] ||= @session_id
+      self.send_raw(hash.to_json, wait_response)
+    end
+  end
+  
+  # Assert that the DirectClient has an awaiting message with +body+.
+  def assert_body(body, subscriber)
+    assert_response subscriber do |result|
+      assert_respond_to result, :[]
+      assert_equal body, result["body"]
+    end
+  end
+  
+  # Assert that the DirectClient has no awaiting message.
+  def assert_no_body(subscriber)
+    assert_response subscriber do |result|
+      assert_equal false, result
+    end
+  end
+  
+  def assert_no_response(subscriber)
+    assert_not_nil subscriber
+    assert_raise(EOFError) { subscriber.receive }
+  ensure
+    subscriber.close
+  end
+  
+  def assert_raw_response(subscriber, response = nil)
+    assert_not_nil subscriber
+    result = nil
+    assert_nothing_raised { result = subscriber.receive(false) }
+    assert_not_nil result
+    if block_given?
+      yield result
+    else
+      assert_equal response, result
+    end
+  ensure
+    subscriber.close
+  end
+  
+  def assert_response(subscriber, response = nil)
+    assert_not_nil subscriber
+    result = nil
+    assert_nothing_raised { result = subscriber.receive }
+    assert_not_nil result
+    if block_given?
+      yield result
+    else
+      assert_equal response, result
+    end
+  ensure
+    subscriber.close
+  end
+  
+  def assert_server_disconnected(subscriber)
+    assert_not_nil subscriber
+    assert_raise(Errno::ECONNRESET, EOFError) { subscriber.receive }
+  end
+  
+  # Convenience method to create a new DirectClient instance with overridable options.
+  # If a block is passed, control is yielded, passing the new client in. This method
+  # returns the value returned from that block, or the new client if no block was given.
+  def new_client(options = { })
+    c = DirectClient.new(OPTIONS.merge(options))
+    if block_given?
+      yield(c)
+    else
+      c
+    end
+  end
+  
+  # Shortcut to run tests that require setting up, starting, then shutting down EventMachine.
+  # So ugly, but EventMachine doesn't have test examples on code that require back-and-forth
+  # communication over a long-running connection.
+  def with_server(options = { }, &block)
+    # We should not have any clients before we start
+    Juggernaut::Client.reset!
+
+    # Save the current options. This is an obvious hack.
+    old_options, Juggernaut.options = Juggernaut.options, OPTIONS.merge(options)
+    Juggernaut.logger.level = Logger::DEBUG
+    
+    # Initialize an array to keep track of connections made to the server in this instance.
+    @connections = [ ]
+    
+    EM.run do
+      # Start the server, and save each connection made so we can refer to it later.
+      EM.start_server(Juggernaut.options[:host], Juggernaut.options[:port], Juggernaut::Server) { |c| @connections << c }
+      
+      # Guard against never-ending tests by shutting off at 2 seconds.
+      EM.add_timer(2) do
+        Juggernaut::Client.send_logouts_to_all_clients
+        EM.stop
+      end
+      
+      # Deferred: evaluate the block and then run the shutdown proc. By using instance_eval,
+      # our block gets access to assert_* methods and the +@connections+ variable above.
+      EM.defer proc {
+        instance_eval(&block)
+      }, proc {
+        # There's probably a better way of doing this, but without this line, different
+        # clients may create a race condition in tests, causing some of them to sometimes
+        # fail. This isn't foolproof either, should any client take more than 200 ms.
+        EM.add_timer(0.2) do
+          Juggernaut::Client.send_logouts_to_all_clients
+          EM.stop
+        end
+      }
+    end
+  ensure
+    # Restore old options.
+    Juggernaut.options = old_options if old_options
+  end
+  
+  context "Server" do
+    
+    should "accept a connection" do
+      with_server do
+        self.new_client do |c|
+          c.transmit :command => :subscribe, :channels => [ ]
+        end
+        assert_equal 1, @connections.select { |c| c.alive? }.size
+        assert_equal true, @connections.first.alive?
+      end
+      assert_equal false, @connections.first.alive?
+    end
+    
+    should "register channels correctly" do
+      with_server do
+        self.new_client { |c| c.transmit :command => :subscribe, :channels => ["master", "slave"] }
+      end
+      assert @connections.first.has_channel?("master")
+      assert_equal false, @connections.first.has_channel?("non_existant")
+      assert @connections.first.has_channels?(["non_existant", "master", "slave"])
+      assert_equal false, @connections.first.has_channels?(["non_existant", "invalid"])
+    end
+    
+    context "channel-wide broadcast" do
+      
+      body = "This is a channel-wide broadcast test!"
+      
+      should "be received by client in the same channel" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_channel") { |c| c.subscribe %w(master) }
+          self.new_client { |c| c.broadcast_to_channels %w(master), body }
+        end
+        assert_not_nil subscriber
+        result = subscriber.receive
+        subscriber.close
+        assert_respond_to result, :[]
+        assert_equal body, result["body"]
+      end
+      
+      should "not be received by client not in a channel" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_channel") { |c| c.subscribe %w() }
+          self.new_client { |c| c.broadcast_to_channels %w(master), body }
+        end
+        assert_no_response subscriber
+      end
+      
+      should "not be received by client in a different channel" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_test") { |c| c.subscribe %w(slave) }
+          self.new_client { |c| c.broadcast_to_channels %w(broadcast_channel), body }
+        end
+        assert_no_response subscriber
+      end
+      
+    end
+    
+    # For some reason, these refuse to pass:
+    context "broadcast with no specific channel" do
+      
+      body = "This is a broadcast test!"
+      
+      should "be received by client not in any channels" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_all") { |c| c.subscribe %w() }
+          self.new_client { |c| c.broadcast_to_channels %w(), body }
+        end
+        assert_body body, subscriber
+      end
+      
+      should "be received by client in a channel" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_all") { |c| c.subscribe %w(master) }
+          self.new_client { |c| c.broadcast_to_channels %w(), body }
+        end
+        assert_body body, subscriber
+      end
+      
+    end
+    
+    context "broadcast to a client" do
+      
+      body = "This is a client-specific broadcast test!"
+      
+      should "be received by the target client" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_client") { |c| c.subscribe %w() }
+          self.new_client { |c| c.broadcast_to_clients %w(broadcast_client), body }
+        end
+        assert_body body, subscriber
+      end
+      
+      should "not be received by other clients" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "broadcast_faker") { |c| c.subscribe %w() }
+          self.new_client { |c| c.broadcast_to_clients %w(broadcast_client), body }
+        end
+        assert_no_response subscriber
+      end
+      
+      should "be saved until the client reconnects" do
+        subscriber = nil
+        with_server :store_messages => true do
+          self.new_client(:client_id => "broadcast_client") { |c| c.subscribe %w() }.close
+          self.new_client { |c| c.broadcast_to_clients %w(broadcast_client), body }
+          subscriber = self.new_client(:client_id => "broadcast_client") { |c| c.subscribe %w() }
+        end
+        assert_body body, subscriber
+      end
+
+      should "only be sent to new client connection" do
+        old_subscriber = nil
+        new_subscriber = nil
+
+        with_server :store_messages => true, :timeout => 30 do 
+          old_subscriber = self.new_client(:client_id => "broadcast_client", :session_id => "1") { |c| c.subscribe %w() }
+          self.new_client { |c| c.broadcast_to_clients %w(broadcast_client), body }
+          @connections.first.client.expects(:send_message_to_connection).times(2)
+          new_subscriber = self.new_client(:client_id => "broadcast_client", :session_id => "2") { |c| c.subscribe %w() }
+        end
+      end
+      
+    end
+    
+    context "querying client list" do
+      
+      should "return all clients" do
+        subscriber = nil
+        with_server do
+          self.new_client(:client_id => "alex") { |c| c.subscribe %w() }
+          self.new_client(:client_id => "bob") { |c| c.subscribe %w() }
+          subscriber = self.new_client(:client_id => "cindy") { |c| c.subscribe %w(); c.query_show_clients }
+        end
+        assert_not_nil subscriber
+        result = subscriber.receive
+        assert_not_nil result
+        assert_equal 3, result.size
+        assert_same_elements %w(alex bob cindy), result.collect { |r| r["client_id"] }
+      end
+      
+      should "not include disconnected clients" do
+        subscriber = nil
+        with_server(:timeout => 0) do
+          self.new_client(:client_id => "sandra") { |c| c.subscribe %w() }
+          self.new_client(:client_id => "tom") { |c| c.subscribe %w() }.close
+          subscriber = self.new_client(:client_id => "vivian") { |c| c.subscribe %w(); c.query_show_clients }
+        end
+        assert_not_nil subscriber
+        result = subscriber.receive
+        assert_not_nil result
+        assert_equal 2, result.size
+        assert_same_elements %w(sandra vivian), result.collect { |r| r["client_id"] }
+      end
+      
+      should "only return requested clients" do
+        subscriber = nil
+        with_server do
+          self.new_client(:client_id => "dixie") { |c| c.subscribe %w() }
+          self.new_client(:client_id => "eamon") { |c| c.subscribe %w() }
+          self.new_client(:client_id => "fanny") { |c| c.subscribe %w() }
+          subscriber = self.new_client(:client_id => "zelda") { |c| c.subscribe %w(); c.query_show_clients %w(dixie fanny) }
+        end
+        assert_not_nil subscriber
+        result = subscriber.receive
+        assert_not_nil result
+        assert_equal 2, result.size
+        assert_same_elements %w(dixie fanny), result.collect { |r| r["client_id"] }
+      end
+      
+      should "never return non-existant clients even when requested" do
+        subscriber = nil
+        with_server do
+          self.new_client(:client_id => "dixie") { |c| c.subscribe %w() }
+          self.new_client(:client_id => "eamon") { |c| c.subscribe %w() }
+          self.new_client(:client_id => "fanny") { |c| c.subscribe %w() }
+          subscriber = self.new_client(:client_id => "zelda") { |c| c.subscribe %w(); c.query_show_clients %w(ginny homer) }
+        end
+        assert_not_nil subscriber
+        result = subscriber.receive
+        assert_not_nil result
+        assert_equal 0, result.size
+      end
+      
+      should "return correct number of active connections" do
+        subscriber = nil
+        with_server do
+          5.times { self.new_client(:client_id => "homer") { |c| c.subscribe %w() } }
+          subscriber = self.new_client(:client_id => "zelda") { |c| c.subscribe %w(); c.query_show_clients %w(homer) }
+        end
+        assert_not_nil subscriber
+        result = subscriber.receive
+        assert_not_nil result
+        assert_equal 1, result.size
+        assert_equal 5, result.first["num_connections"]
+      end
+      
+      should "be equivalent when querying one client" do
+        s1, s2 = nil
+        with_server do
+          5.times { self.new_client(:client_id => "homer") { |c| c.subscribe %w() } }
+          s1 = self.new_client(:client_id => "zelda") { |c| c.subscribe %w(); c.query_show_client "homer" }
+          s2 = self.new_client(:client_id => "zelda") { |c| c.subscribe %w(); c.query_show_clients %w(homer) }
+        end
+        assert_not_nil s1
+        assert_not_nil s2
+        r1 = s1.receive
+        assert_not_nil r1
+        r2 = s2.receive
+        assert_not_nil r2
+        assert_equal 1, r2.size
+        assert_equal r1, r2.first
+      end
+      
+      should "only return clients in specific channels" do
+        subscriber = nil
+        with_server do
+          self.new_client(:client_id => "alexa") { |c| c.subscribe %w(master slave zoo) }
+          self.new_client(:client_id => "bobby") { |c| c.subscribe %w(master slave) }
+          self.new_client(:client_id => "cindy") { |c| c.subscribe %w(master zoo) }
+          self.new_client(:client_id => "dixon") { |c| c.subscribe %w(slave zoo) }
+          self.new_client(:client_id => "eamon") { |c| c.subscribe %w(slave) }
+          self.new_client(:client_id => "flack") { |c| c.subscribe %w(decoy slave) }
+          subscriber = self.new_client(:client_id => "geoff") { |c| c.subscribe %w(zoo); c.query_show_clients_for_channels %w(master zoo) }
+        end
+        assert_response subscriber do |result|
+          assert_equal 5, result.size
+          assert_same_elements %w(alexa bobby cindy dixon geoff), result.collect { |r| r["client_id"] }
+        end
+      end
+      
+    end
+    
+    context "upon processing an invalid command" do
+      
+      should "disconnect immediately" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "pinocchio") { |c| c.transmit :command => :some_undefined_command; c.subscribe %w(); c }
+        end
+        assert_server_disconnected subscriber
+      end
+      
+    end
+    
+    %w(broadcast subscribe query).each do |type|
+      
+      context "upon receiving malformed #{type}" do
+        
+        should "disconnect immediately" do
+          subscriber = nil
+          with_server do
+            subscriber = self.new_client(:client_id => "pinocchio") { |c| c.transmit :command => type, :type => :unknown; c.subscribe %w(); c }
+          end
+          assert_server_disconnected subscriber
+        end
+        
+      end
+      
+    end
+    
+    context "upon receiving invalid JSON" do
+      
+      should "disconnect immediately" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "pinocchio") { |c| c.send_raw "invalid json..."; c }
+        end
+        assert_server_disconnected subscriber
+      end
+      
+    end
+    
+    context "crossdomain file request" do
+      
+      should "return contents of crossdomain file" do
+        subscriber = nil
+        with_server do
+          subscriber = self.new_client(:client_id => "pinocchio") { |c| c.request_crossdomain_file }
+        end
+        assert_raw_response subscriber, <<-EOF
+      <cross-domain-policy>
+        <allow-access-from domain="*" to-ports="#{OPTIONS[:port]}" />
+      </cross-domain-policy>
+    EOF
+      end
+      
+    end
+    
+    context "querying channel list" do
+      
+      should "return channel list" do
+        subscribe = nil
+        with_server do
+          self.new_client(:client_id => "homer") { |c| c.subscribe %w(groupie master slave1 slave2) }
+          self.new_client(:client_id => "marge") { |c| c.subscribe %w(master slave1 slave2) }
+          subscribe = self.new_client(:client_id => "pinocchio") { |c|
+            c.subscribe %w(master slave1)
+            c.query_show_channels_for_client "marge"
+          }
+        end
+        assert_response subscribe do |result|
+          assert_equal 3, result.size 
+          assert_same_elements %w(master slave1 slave2), result
+        end
+      end
+      
+    end
+    
+    context "remove channel request" do
+      
+      should "work on all clients when requested" do
+        with_server do
+          self.new_client(:client_id => "homer") { |c| c.subscribe %w(groupie master slave1 slave2) }
+          self.new_client(:client_id => "marge") { |c| c.subscribe %w(master slave1 slave2) }
+          self.new_client(:client_id => "pinocchio") { |c|
+            c.subscribe %w(master slave1 slave2)
+            c.query_remove_channels_from_all_clients %w(slave1 slave2)
+          }
+        end
+        @connections.each do |connection|
+          assert_does_not_contain connection.channels, /slave/
+        end
+      end
+      
+      should "work on specific clients when requested" do
+        with_server do
+          self.new_client(:client_id => "homer") { |c| c.subscribe %w(groupie master slave1 slave2) }
+          self.new_client(:client_id => "marge") { |c| c.subscribe %w(master slave1 slave2) }
+          self.new_client(:client_id => "pinocchio") { |c|
+            c.subscribe %w(master slave1 slave2)
+            c.query_remove_channels_from_client %w(slave1 slave2), %w(homer)
+          }
+        end
+        assert_does_not_contain @connections.find { |c| c.instance_eval("@request[:client_id]") == "homer" }.channels, /slave/
+        assert_contains @connections.find { |c| c.instance_eval("@request[:client_id]") == "marge" }.channels, /slave/
+      end
+      
+    end
+    
+  end
+  
+end