faye 0.5.5 → 0.6.0

data/spec/ruby/engine_spec.rb

@@ -0,0 +1,312 @@
+require "spec_helper"
+
+EngineSteps = EM::RSpec.async_steps do
+  def create_client(name, &resume)
+    @inboxes ||= {}
+    @clients ||= {}
+    engine.create_client do |client_id|
+      @clients[name] = client_id
+      @inboxes[name] ||= []
+      resume.call
+    end
+  end
+  
+  def connect(name, engine, &resume)
+    engine.connect(@clients[name]) do |m|
+      m.each do |message|
+        message.delete("id")
+        @inboxes[name] << message
+      end
+    end
+    EM.add_timer(0.01, &resume)
+  end
+  
+  def destroy_client(name, &resume)
+    engine.destroy_client(@clients[name], &resume)
+  end
+  
+  def check_client_id(name, pattern, &resume)
+    @clients[name].should =~ pattern
+    resume.call
+  end
+  
+  def check_num_clients(n, &resume)
+    ids = Set.new
+    @clients.each { |name,id| ids.add(id) }
+    ids.size.should == n
+    resume.call
+  end
+  
+  def check_client_exists(name, exists, &resume)
+    engine.client_exists(@clients[name]) do |actual|
+      actual.should == exists
+      resume.call
+    end
+  end
+  
+  def subscribe(name, channel, &resume)
+    engine.subscribe(@clients[name], channel, &resume)
+  end
+  
+  def unsubscribe(name, channel, &resume)
+    engine.unsubscribe(@clients[name], channel, &resume)
+  end
+  
+  def publish(messages, &resume)
+    messages = [messages].flatten
+    messages.each do |message|
+      message = {"id" => Faye.random}.merge(message)
+      engine.publish(message)
+    end
+    EM.add_timer(0.01, &resume)
+  end
+  
+  def ping(name, &resume)
+    engine.ping(@clients[name])
+    resume.call
+  end
+  
+  def clock_tick(time, &resume)
+    clock.tick(time)
+    resume.call
+  end
+  
+  def expect_message(name, messages, &resume)
+    @inboxes[name].should == messages
+    resume.call
+  end
+  
+  def expect_no_message(name, &resume)
+    @inboxes[name].should == []
+    resume.call
+  end
+  
+  def clean_redis_db(&resume)
+    engine.disconnect
+    redis = EM::Hiredis::Client.connect
+    redis.flushall(&resume)
+  end
+end
+
+describe "Pub/sub engines" do
+  shared_examples_for "faye engine" do
+    include EngineSteps
+    
+    let(:options) { {:timeout => 1} }
+    let(:engine) { engine_klass.new options }
+    
+    before do
+      Faye.ensure_reactor_running!
+      create_client :alice
+      create_client :bob
+      create_client :carol
+    end
+    
+    describe :create_client do
+      it "returns a client id" do
+        create_client :dave
+        check_client_id :dave, /^[a-z0-9]+$/
+      end
+      
+      it "returns a different id every time" do
+        1.upto(7) { |i| create_client "client#{i}" }
+        check_num_clients 10
+      end
+    end
+    
+    describe :client_exists do
+      it "returns true if the client id exists" do
+        check_client_exists :alice, true
+      end
+      
+      it "returns false if the client id does not exist" do
+        check_client_exists :anything, false
+      end
+    end
+=begin
+    describe :ping do
+      it "removes a client if it does not ping often enough" do
+        clock_tick 2
+        check_client_exists :alice, false
+      end
+      
+      it "prolongs the life of a client" do
+        clock_tick 1
+        ping :alice
+        clock_tick 1
+        check_client_exists :alice, true
+        clock_tick 1
+        check_client_exists :alice, false
+      end
+    end
+=end
+    describe :destroy_client do
+      it "removes the given client" do
+        destroy_client :alice
+        check_client_exists :alice, false
+      end
+      
+      describe "when the client has subscriptions" do
+        before do
+          @message = {"channel" => "/messages/foo", "data" => "ok"}
+          subscribe :alice, "/messages/foo"
+        end
+        
+        it "stops the client receiving messages" do
+          connect :alice, engine
+          destroy_client :alice
+          publish @message
+          expect_no_message :alice
+        end
+      end
+    end
+    
+    describe :publish do
+      before do
+        @message = {"channel" => "/messages/foo", "data" => "ok"}
+        connect :alice, engine
+        connect :bob,   engine
+        connect :carol, engine
+      end
+      
+      describe "with no subscriptions" do
+        it "delivers no messages" do
+          publish @message
+          expect_no_message :alice
+          expect_no_message :bob
+          expect_no_message :carol
+        end
+      end
+      
+      describe "with a subscriber" do
+        before { subscribe :alice, "/messages/foo" }
+        
+        it "delivers messages to the subscribed client" do
+          publish @message
+          expect_message :alice, [@message]
+        end
+      end
+      
+      describe "with a subscriber that is removed" do
+        before do
+          subscribe :alice, "/messages/foo"
+          unsubscribe :alice, "/messages/foo"
+        end
+        
+        it "does not deliver messages to unsubscribed clients" do
+          publish @message
+          expect_no_message :alice
+          expect_no_message :bob
+          expect_no_message :carol
+        end
+      end
+      
+      describe "with multiple subscribers" do
+        before do
+          subscribe :alice, "/messages/foo"
+          subscribe :bob,   "/messages/bar"
+          subscribe :carol, "/messages/foo"
+        end
+        
+        it "delivers messages to the subscribed clients" do
+          publish @message
+          expect_message    :alice, [@message]
+          expect_no_message :bob
+          expect_message    :carol, [@message]
+        end
+      end
+      
+      describe "with a single wildcard" do
+        before do
+          subscribe :alice, "/messages/*"
+          subscribe :bob,   "/messages/bar"
+          subscribe :carol, "/*"
+        end
+        
+        it "delivers messages to matching subscriptions" do
+          publish @message
+          expect_message    :alice, [@message]
+          expect_no_message :bob
+          expect_no_message :carol
+        end
+      end
+      
+      describe "with a double wildcard" do
+        before do
+          subscribe :alice, "/messages/**"
+          subscribe :bob,   "/messages/bar"
+          subscribe :carol, "/**"
+        end
+        
+        it "delivers messages to matching subscriptions" do
+          publish @message
+          expect_message    :alice, [@message]
+          expect_no_message :bob
+          expect_message    :carol, [@message]
+        end
+      end
+      
+      describe "with multiple matching subscriptions for the same client" do
+        before do
+          subscribe :alice, "/messages/foo"
+          subscribe :alice, "/messages/*"
+        end
+        
+        it "delivers each message once to each client" do
+          publish @message
+          expect_message :alice, [@message]
+        end
+        
+        it "delivers the message as many times as it is published" do
+          publish [@message, @message]
+          expect_message :alice, [@message, @message]
+        end
+      end
+    end
+  end
+  
+  shared_examples_for "distributed engine" do
+    include EngineSteps
+    
+    let(:options) { {} }
+    let(:left)  { engine_klass.new options }
+    let(:right) { engine_klass.new options }
+    
+    alias :engine :left
+    
+    before do
+      Faye.ensure_reactor_running!
+      create_client :alice
+      create_client :bob
+      
+      connect :alice, left
+    end
+    
+    describe :publish do
+      before do
+        subscribe :alice, "/foo"
+        publish "channel" => "/foo", "data" => "first"
+      end
+      
+      it "only delivers each message once" do
+        expect_message :alice, ["channel" => "/foo", "data" => "first"]
+        publish "channel" => "/foo", "data" => "second"
+        connect :alice, right
+        expect_message :alice, [{"channel" => "/foo", "data" => "first"}, {"channel" => "/foo", "data" => "second"}]
+      end
+    end
+  end
+  
+  describe Faye::Engine::Memory do
+    let(:engine_klass) { Faye::Engine::Memory }
+    it_should_behave_like "faye engine"
+  end
+  
+  describe Faye::Engine::Redis do
+    let(:engine_klass) { Faye::Engine::Redis }
+    after { clean_redis_db }
+    it_should_behave_like "faye engine"
+    it_should_behave_like "distributed engine"
+  end
+end
+

data/spec/ruby/faye_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Faye do
+  describe :random do
+    it "returns a 128-bit random number in base 36" do
+      Faye.random.should =~ /^[a-z0-9]+$/
+    end
+    
+    it "always produces the same length of string" do
+      ids = (1..100).map { Faye.random }
+      ids.should be_all { |id| id.size == 25 }
+    end
+  end
+end

data/spec/ruby/grammar_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Faye::Grammar do
+  describe :CHANNEL_NAME do
+    it "matches valid channel names" do
+      Faye::Grammar::CHANNEL_NAME.should =~ "/fo_o/$@()bar"
+    end
+    
+    it "does not match channel patterns" do
+      Faye::Grammar::CHANNEL_NAME.should_not =~ "/foo/**"
+    end
+    
+    it "does not match invalid channel names" do
+      Faye::Grammar::CHANNEL_NAME.should_not =~ "foo/$@()bar"
+      Faye::Grammar::CHANNEL_NAME.should_not =~ "/foo/$@()bar/"
+      Faye::Grammar::CHANNEL_NAME.should_not =~ "/fo o/$@()bar"
+    end
+  end
+  
+  describe :CHANNEL_PATTERN do
+    it "does not match channel names" do
+      Faye::Grammar::CHANNEL_PATTERN.should_not =~ "/fo_o/$@()bar"
+    end
+    
+    it "matches valid channel patterns" do
+      Faye::Grammar::CHANNEL_PATTERN.should =~ "/foo/**"
+      Faye::Grammar::CHANNEL_PATTERN.should =~ "/foo/*"
+    end
+    
+    it "does not match invalid channel patterns" do
+      Faye::Grammar::CHANNEL_PATTERN.should_not =~ "/foo/**/*"
+    end
+  end
+  
+  describe :ERROR do
+    it "matches an error with an argument" do
+      Faye::Grammar::ERROR.should =~ "402:xj3sjdsjdsjad:Unknown Client ID"
+    end
+    
+    it "matches an error with many arguments" do
+      Faye::Grammar::ERROR.should =~ "403:xj3sjdsjdsjad,/foo/bar:Subscription denied"
+    end
+    
+    it "matches an error with no arguments" do
+      Faye::Grammar::ERROR.should =~ "402::Unknown Client ID"
+    end
+    
+    it "does not match an error with no code" do
+      Faye::Grammar::ERROR.should_not =~ ":xj3sjdsjdsjad:Unknown Client ID"
+    end
+    
+    it "does not match an error with an invalid code" do
+      Faye::Grammar::ERROR.should_not =~ "40:xj3sjdsjdsjad:Unknown Client ID"
+    end
+  end
+  
+  describe :VERSION do
+    it "matches a version number" do
+      Faye::Grammar::VERSION.should =~ "9"
+      Faye::Grammar::VERSION.should =~ "9.0.a-delta1"
+    end
+    
+    it "does not match invalid version numbers" do
+      Faye::Grammar::VERSION.should_not =~ "9.0.a-delta1."
+      Faye::Grammar::VERSION.should_not =~ ""
+    end
+  end
+end

data/spec/ruby/rack_adapter_spec.rb

@@ -0,0 +1,209 @@
+require "spec_helper"
+require "thin_proxy"
+
+describe Faye::RackAdapter do
+  include Rack::Test::Methods
+  let(:app)     { ThinProxy.new(Faye::RackAdapter.new options) }
+  let(:options) { {:mount => "/bayeux", :timeout => 30} }
+  let(:server)  { mock "server" }
+  
+  after { app.stop }
+  
+  let(:content_type)          { last_response["Content-Type"] }
+  let(:access_control_origin) { last_response["Access-Control-Allow-Origin"] }
+  let(:json)                  { JSON.parse(body) }
+  let(:body)                  { last_response.body }
+  let(:status)                { last_response.status.to_i }
+  
+  before do
+    Faye::Server.should_receive(:new).with(options).and_return server
+  end
+  
+  describe "POST requests" do
+    describe "with cross-origin access control" do
+      before do
+        header "Origin", "http://example.com"
+      end
+      
+      it "returns a matching cross-origin access control header" do
+        server.stub(:process).and_yield []
+        post "/bayeux", :message => '[]'
+        access_control_origin.should == "http://example.com"
+      end
+      
+      it "forwards the message param onto the server" do
+        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
+        post "/bayeux", :message => '{"channel":"/foo"}'
+      end
+      
+      it "returns the server's response as JSON" do
+        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
+        post "/bayeux", :message => '[]'
+        status.should == 200
+        content_type.should == "application/json"
+        json.should == ["channel" => "/meta/handshake"]
+      end
+      
+      it "returns a 400 response if malformed JSON is given" do
+        server.should_not_receive(:process)
+        post "/bayeux", :message => "[}"
+        status.should == 400
+        content_type.should == "text/plain"
+      end
+      
+      it "returns a 404 if the path is not matched" do
+        server.should_not_receive(:process)
+        post "/blaf", :message => "[]"
+        status.should == 404
+        content_type.should == "text/plain"
+      end
+    end
+    
+    describe "with application/json" do
+      before do
+        header "Content-Type", "application/json"
+      end
+      
+      it "does not return an access control header" do
+        server.stub(:process).and_yield []
+        post "/bayeux", :message => '[]'
+        access_control_origin.should be_nil
+      end
+      
+      it "forwards the POST body onto the server" do
+        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
+        post "/bayeux", '{"channel":"/foo"}'
+      end
+      
+      it "returns the server's response as JSON" do
+        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
+        post "/bayeux", '[]'
+        status.should == 200
+        content_type.should == "application/json"
+        json.should == ["channel" => "/meta/handshake"]
+      end
+      
+      it "returns a 400 response if malformed JSON is given" do
+        server.should_not_receive(:process)
+        post "/bayeux", "[}"
+        status.should == 400
+        content_type.should == "text/plain"
+      end
+      
+      it "returns a 404 if the path is not matched" do
+        server.should_not_receive(:process)
+        post "/blaf", "[]"
+        status.should == 404
+        content_type.should == "text/plain"
+      end
+    end
+    
+    describe "with no content type" do
+      it "forwards the message param onto the server" do
+        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
+        post "/bayeux", :message => '{"channel":"/foo"}'
+      end
+      
+      it "returns the server's response as JSON" do
+        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
+        post "/bayeux", :message => '[]'
+        status.should == 200
+        content_type.should == "application/json"
+        json.should == ["channel" => "/meta/handshake"]
+      end
+      
+      it "returns a 400 response if malformed JSON is given" do
+        server.should_not_receive(:process)
+        post "/bayeux", :message => "[}"
+        status.should == 400
+        content_type.should == "text/plain"
+      end
+      
+      it "returns a 404 if the path is not matched" do
+        server.should_not_receive(:process)
+        post "/blaf", :message => "[]"
+        status.should == 404
+        content_type.should == "text/plain"
+      end
+    end
+  end
+  
+  describe "GET requests" do
+    let(:params) {{:message => '{"channel":"/foo"}', :jsonp => "callback"}}
+    
+    describe "with valid params" do
+      before do
+        server.should_receive(:flush_connection).with("channel" => "/foo")
+      end
+      
+      it "forwards the message param onto the server" do
+        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
+        get "/bayeux", params
+      end
+      
+      it "returns the server's response as JavaScript" do
+        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
+        get "/bayeux", params
+        status.should == 200
+        content_type.should == "text/javascript"
+        body.should == 'callback([{"channel":"/meta/handshake"}]);'
+      end
+    end
+    
+    describe "with an unknown path" do
+      it "returns a 404" do
+        server.should_not_receive(:process)
+        get "/blah", params
+        status.should == 404
+        content_type.should == "text/plain"
+      end
+    end
+    
+    describe "missing jsonp" do
+      before do
+        params.delete(:jsonp)
+        server.should_receive(:flush_connection)
+      end
+      
+      it "returns the server's response using the default callback" do
+        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
+        get "/bayeux", params
+        status.should == 200
+        content_type.should == "text/javascript"
+        body.should == 'jsonpcallback([{"channel":"/meta/handshake"}]);'
+      end
+    end
+    
+    shared_examples_for "bad GET request" do
+      it "does not call the server" do
+        server.should_not_receive(:process)
+        get "/bayeux", params
+      end
+      
+      it "returns a 400 response" do
+        get "/bayeux", params
+        status.should == 400
+        content_type.should == "text/plain"
+      end
+    end
+    
+    describe "with malformed JSON" do
+      before { params[:message] = "[}" }
+      it_should_behave_like "bad GET request"
+    end
+    
+    describe "missing message" do
+      before { params.delete(:message) }
+      it_should_behave_like "bad GET request"
+    end
+    
+    describe "for the client script" do
+      it "returns the client script" do
+        get "/bayeux.js"
+        status.should == 200
+        content_type.should == "text/javascript"
+        body.should =~ /function\(\)\{/
+      end
+    end
+  end
+end