faye 0.5.5 → 0.6.0

data/spec/ruby/server_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+describe Faye::Server do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+  
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  
+  describe :process do
+    let(:handshake)   {{"channel" => "/meta/handshake",   "data" => "handshake"  }}
+    let(:connect)     {{"channel" => "/meta/connect",     "data" => "connect"    }}
+    let(:disconnect)  {{"channel" => "/meta/disconnect",  "data" => "disconnect" }}
+    let(:subscribe)   {{"channel" => "/meta/subscribe",   "data" => "subscribe"  }}
+    let(:unsubscribe) {{"channel" => "/meta/unsubscribe", "data" => "unsubscribe"}}
+    let(:publish)     {{"channel" => "/some/channel",     "data" => "publish"    }}
+    
+    before do
+      engine.stub(:interval).and_return(0)
+      engine.stub(:timeout).and_return(60)
+    end
+    
+    it "returns an empty response for no messages" do
+      response = nil
+      server.process([], false) { |r| response = r }
+      response.should == []
+    end
+    
+    it "ignores invalid messages" do
+      response = nil
+      server.process([{}, {"channel" => "invalid"}], false) { |r| response = r }
+      response.should == []
+    end
+    
+    it "routes single messages to appropriate handlers" do
+      server.should_receive(:handshake).with(handshake, false)
+      engine.should_receive(:publish).with(handshake)
+      server.process(handshake, false)
+    end
+    
+    it "routes a list of messages to appropriate handlers" do
+      server.should_receive(:handshake).with(handshake, false)
+      server.should_receive(:connect).with(connect, false)
+      server.should_receive(:disconnect).with(disconnect, false)
+      server.should_receive(:subscribe).with(subscribe, false)
+      server.should_receive(:unsubscribe).with(unsubscribe, false)
+      
+      engine.should_receive(:publish).with(handshake)
+      engine.should_receive(:publish).with(connect)
+      engine.should_receive(:publish).with(disconnect)
+      engine.should_receive(:publish).with(subscribe)
+      engine.should_receive(:publish).with(unsubscribe)
+      engine.should_receive(:publish).with(publish)
+      
+      server.process([handshake, connect, disconnect, subscribe, unsubscribe, publish], false)
+    end
+    
+    describe "publishing a message" do
+      it "tells the engine to publish the message" do
+        engine.should_receive(:publish).with(publish)
+        server.process(publish, false) {}
+      end
+      
+      it "returns no response" do
+        engine.stub(:publish)
+        server.process(publish, false) { |r| r.should == [] }
+      end
+      
+      describe "with an error" do
+        before { publish["error"] = "invalid" }
+        
+        it "does not tell the engine to publish the message" do
+          engine.should_not_receive(:publish)
+          server.process(publish, false) {}
+        end
+        
+        it "returns no response" do
+          engine.stub(:publish)
+          server.process(publish, false) { |r| r.should == [] }
+        end
+      end
+
+      describe "to an invalid channel" do
+        before { publish["channel"] = "/invalid/*" }
+
+        it "does not tell the engine to publish the message" do
+          engine.should_not_receive(:publish)
+          server.process(publish, false) {}
+        end
+      end
+    end
+    
+    describe "handshaking" do
+      before do
+        engine.should_receive(:publish).with(handshake)
+        server.should_receive(:handshake).with(handshake, false).and_yield({"successful" => true})
+      end
+      
+      it "returns the handshake response with advice" do
+        server.process(handshake, false) do |response|
+          response.should == [
+            { "successful" => true,
+              "advice" => {"reconnect" => "retry", "interval" => 0, "timeout" => 60000}
+            }
+          ]
+        end
+      end
+    end
+    
+    describe "connecting for messages" do
+      let(:messages) { [{"channel" => "/a"}, {"channel" => "/b"}] }
+      
+      before do
+        engine.should_receive(:publish).with(connect)
+        server.should_receive(:connect).with(connect, false).and_yield(messages)
+      end
+      
+      it "returns the new messages" do
+        server.process(connect, false) { |r| r.should == messages }
+      end
+    end
+  end
+  
+  describe :flush_connection do
+    let(:message) {{"clientId" => "fakeclientid"}}
+    
+    it "flushes the connection when given one message" do
+      engine.should_receive(:flush).with("fakeclientid")
+      server.flush_connection(message)
+    end
+    
+    it "flushes the connection when given a list of messages" do
+      engine.should_receive(:flush).with("fakeclientid")
+      server.flush_connection([message])
+    end
+  end
+end

data/spec/ruby/transport_spec.rb

@@ -0,0 +1,128 @@
+require "spec_helper"
+
+describe Faye::Transport do
+  let :client do
+    client = mock("client")
+    client.stub(:endpoint).and_return("http://example.com/")
+    client
+  end
+  
+  describe :get do
+    before do
+      Faye::Transport::Local.stub(:usable?).and_return(false)
+      Faye::Transport::Http.stub(:usable?).and_return(false)
+    end
+    
+    let(:transport)       { Faye::Transport.get(client, ["long-polling", "in-process"]) }
+    let(:local_transport) { Faye::Transport.get(client, ["in-process"]) }
+    let(:http_transport)  { Faye::Transport.get(client, ["long-polling"]) }
+    
+    describe "when no transport is usable" do
+      it "raises an exception" do
+        lambda { transport }.should raise_error
+      end
+    end
+    
+    describe "when a less preferred transport is usable" do
+      before do
+        Faye::Transport::Http.stub(:usable?).and_return(true)
+      end
+      
+      it "returns a transport of the usable type" do
+        transport.should be_kind_of(Faye::Transport::Http)
+      end
+      
+      it "rasies an exception of the usable type is not requested" do
+        lambda { local_transport }.should raise_error
+      end
+      
+      it "allows the usable type to be specifically selected" do
+        http_transport.should be_kind_of(Faye::Transport::Http)
+      end
+    end
+    
+    describe "when all transports are usable" do
+      before do
+        Faye::Transport::Local.stub(:usable?).and_return(true)
+        Faye::Transport::Http.stub(:usable?).and_return(true)
+      end
+      
+      it "returns the most preferred type" do
+        transport.should be_kind_of(Faye::Transport::Local)
+      end
+      
+      it "allows types to be specifically selected" do
+        local_transport.should be_kind_of(Faye::Transport::Local)
+        http_transport.should be_kind_of(Faye::Transport::Http)
+      end
+    end
+  end
+  
+  describe :send do
+    include EM::RSpec::FakeClock
+    before { clock.stub }
+    after { clock.reset }
+    
+    before do
+      client.stub(:client_id).and_return("abc123")
+    end
+    
+    describe "for batching transports" do
+      before do
+        transport_klass = Class.new(Faye::Transport) do
+          def batching?
+            true
+          end
+        end
+        @transport = transport_klass.new(client, "")
+      end
+      
+      it "does not make an immediate request" do
+        @transport.should_not_receive(:request)
+        @transport.send({"batch" => "me"}, 60)
+      end
+      
+      it "queues the message to be sent after a timeout" do
+        @transport.should_receive(:request).with([{"batch" => "me"}], 60)
+        @transport.send({"batch" => "me"}, 60)
+        clock.tick(0.01)
+      end
+      
+      it "allows multiple messages to be batched together" do
+        @transport.should_receive(:request).with([{"id" => 1}, {"id" => 2}], 60)
+        @transport.send({"id" => 1}, 60)
+        @transport.send({"id" => 2}, 60)
+        clock.tick(0.01)
+      end
+      
+      it "adds advice to connect messages sent with others" do
+        @transport.should_receive(:request).with([{"channel" => "/meta/connect", "advice" => {"timeout" => 0}}, {}], 60)
+        @transport.send({"channel" => "/meta/connect"}, 60)
+        @transport.send({}, 60)
+        clock.tick(0.01)
+      end
+      
+      it "adds no advice to connect messages sent alone" do
+        @transport.should_receive(:request).with([{"channel" => "/meta/connect"}], 60)
+        @transport.send({"channel" => "/meta/connect"}, 60)
+        clock.tick(0.01)
+      end
+    end
+    
+    describe "for non-batching transports" do
+      before do
+        transport_klass = Class.new(Faye::Transport) do
+          def batching?
+            false
+          end
+        end
+        @transport = transport_klass.new(client, "")
+      end
+      
+      it "makes a request immediately" do
+        @transport.should_receive(:request).with([{"no" => "batch"}], 60)
+        @transport.send({"no" => "batch"}, 60)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+dir = File.expand_path(File.dirname(__FILE__))
+require dir + '/../lib/faye'
+require dir + '/../vendor/em-rspec/lib/em-rspec'
+require 'rack/test'

data/spec/testswarm.pl

@@ -0,0 +1,200 @@
+#!/usr/bin/perl
+
+# CONFIGURE
+
+# The location of the TestSwarm that you're going to run against.
+
+my $SWARM = "http://swarm.jcoglan.com";
+my $SWARM_INJECT = "/js/inject.js";
+
+# Your TestSwarm username.
+
+my $USER = "faye";
+
+# Your authorization token.
+
+my $AUTH_TOKEN = "6d26e250d81b32099fccc59db53a3a0e648f0e6d";
+
+# The maximum number of times you want the tests to be run.
+
+my $MAX_RUNS = 5;
+
+# The type of revision control system being used.
+# Currently "svn" or "git" are supported.
+
+my $RCS_TYPE = "git";
+
+# The URL from which a copy will be checked out.
+
+my $RCS_URL = "git://github.com/jcoglan/faye.git";
+
+# The directory in which the checkouts will occur.
+
+my $BASE_DIR = "/home/jcoglan/www/swarm.jcoglan.com/app/changeset/$USER";
+
+# A script tag loading in the TestSwarm injection script will
+# be added at the bottom of the <head> in the following file.
+
+my $INJECT_FILE = "spec/browser.html";
+
+# Any build commands that need to happen.
+
+my $BUILD = "git submodule init && git submodule update && cd vendor/js.class && jake && cd ../.. && rm -rf build && jake";
+
+# The name of the job that will be submitted
+# (pick a descriptive, but short, name to make it easy to search)
+
+# Note: The string {REV} will be replaced with the current
+#       commit number/hash.
+
+my $JOB_NAME = "Faye Commit #{REV}";
+
+# The browsers you wish to run against. Options include:
+#  - "all" all available browsers.
+#  - "popular" the most popular browser (99%+ of all browsers in use)
+#  - "current" the current release of all the major browsers
+#  - "gbs" the browsers currently supported in Yahoo's Graded Browser Support
+#  - "beta" upcoming alpha/beta of popular browsers
+#  - "popularbeta" the most popular browser and their upcoming releases
+
+my $BROWSERS = "all";
+
+# All the suites that you wish to run within this job
+# (can be any number of suites)
+
+my %SUITES = ();
+
+# Comment these out if you wish to define a custom set of SUITES above
+my $SUITE = "$SWARM/changeset/$USER/{REV}";
+sub BUILD_SUITES {
+	%SUITES = map { /(\w+).html/; $1 => "$SUITE/$_"; } glob($INJECT_FILE);
+}
+
+########### NO NEED TO CONFIGURE BELOW HERE ############
+
+my $DEBUG = 1;
+my $curdate = time;
+my $co_dir = "tmp-$curdate";
+
+print "chdir $BASE_DIR\n" if ( $DEBUG );
+chdir( $BASE_DIR );
+
+# Check out a specific revision
+if ( $RCS_TYPE eq "svn" ) {
+	print "svn co $RCS_URL $co_dir\n" if ( $DEBUG );
+	`svn co $RCS_URL $co_dir`;
+} elsif ( $RCS_TYPE eq "git" ) {
+	print "git clone $RCS_URL $co_dir\n" if ( $DEBUG );
+	`git clone $RCS_URL $co_dir`;
+}
+
+if ( ! -e $co_dir ) {
+	die "Problem checking out source.";
+}
+
+print "chdir $co_dir\n" if ( $DEBUG );
+chdir( $co_dir );
+
+my $rev;
+
+# Figure out the revision of the checkout
+if ( $RCS_TYPE eq "svn" ) {
+	print "svn info | grep Revision\n" if ( $DEBUG );
+	$rev = `svn info | grep Revision`;
+	$rev =~ s/Revision: //;
+} elsif ( $RCS_TYPE eq "git" ) {
+	print "git log --abbrev-commit | head -1\n" if ( $DEBUG );
+	$rev = `git log --abbrev-commit | head -1`;
+	$rev =~ s/commit.*?(\w+).*$/$1/;
+}
+
+$rev =~ s/\s*//g;
+
+print "Revision: $rev\n" if ( $DEBUG );
+
+if ( ! $rev ) {
+	remove_tmp();
+	die "Revision information not found.";
+
+} elsif ( ! -e "../$rev" ) {
+	print "chdir $BASE_DIR\n" if ( $DEBUG );
+	chdir( $BASE_DIR );
+
+	print "rename $co_dir $rev\n" if ( $DEBUG );
+	rename( $co_dir, $rev );
+
+	print "chdir $rev\n" if ( $DEBUG );
+	chdir ( $rev );
+
+	if ( $BUILD ) {
+		print "$BUILD\n" if ( $DEBUG );
+		`$BUILD`;
+	}
+
+	if ( exists &BUILD_SUITES ) {
+		&BUILD_SUITES();
+	}
+
+	foreach my $file ( glob($INJECT_FILE) ) {
+		my $inject_file = `cat $file`;
+
+		# Inject the TestSwarm injection script into the test suite
+		$inject_file =~ s/<\/head>/<script>document.write("<scr" + "ipt src='$SWARM$SWARM_INJECT?" + (new Date).getTime() + "'><\/scr" + "ipt>");<\/script><\/head>/;
+
+		open( F, ">$file" );
+		print F $inject_file;
+		close( F );
+	}
+
+	my %props = (
+		"state" => "addjob",
+		"output" => "dump",
+		"user" => $USER,
+		"max" => $MAX_RUNS,
+		"job_name" => $JOB_NAME,
+		"browsers" => $BROWSERS,
+		"auth" => $AUTH_TOKEN
+	);
+
+	my $query = "";
+
+	foreach my $prop ( keys %props ) {
+		$query .= ($query ? "&" : "") . $prop . "=" . clean($props{$prop});
+	}
+
+	foreach my $suite ( sort keys %SUITES ) {
+		$query .= "&suites[]=" . clean($suite) .
+		          "&urls[]=" . clean($SUITES{$suite});
+	}
+
+	print "curl -d \"$query\" $SWARM\n" if ( $DEBUG );
+
+	my $results = `curl -d "$query" $SWARM`;
+
+	print "Results: $results\n" if ( $DEBUG );
+
+	if ( $results ) {
+		open( F, ">$rev/results.txt" );
+		print F "$SWARM$results";
+		close( F );
+
+	} else {
+		die "Job not submitted properly.";
+	}
+
+# Otherwise, give up and clean up
+} else {
+	remove_tmp();
+}
+
+sub remove_tmp {
+	chdir( $BASE_DIR );
+	`rm -rf $co_dir`;
+}
+
+sub clean {
+  my $str = shift;
+	$str =~ s/{REV}/$rev/g;
+	$str =~ s/([^A-Za-z0-9])/sprintf("%%%02X", ord($1))/seg;
+	$str;
+}