face-faye 0.8.9

data/spec/ruby/server/disconnect_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe "server disconnect" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+
+  describe :disconnect do
+    let(:client_id) { "fakeclientid" }
+    let(:message) {{"channel" => "/meta/disconnect",
+                    "clientId" => "fakeclientid"
+                  }}
+
+    describe "with valid parameters" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+
+      it "destroys the client" do
+        engine.should_receive(:destroy_client).with(client_id)
+        server.disconnect(message) {}
+      end
+
+      it "returns a successful response" do
+        engine.stub(:destroy_client)
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => true,
+            "clientId"   => client_id
+          }
+        end
+      end
+
+      describe "with a message id" do
+        before { message["id"] = "foo" }
+
+        it "returns the same id" do
+          engine.stub(:destroy_client)
+          server.disconnect(message) do |response|
+            response.should == {
+              "channel"    => "/meta/disconnect",
+              "successful" => true,
+              "clientId"   => client_id,
+              "id"         => "foo"
+            }
+          end
+        end
+      end
+    end
+
+    describe "with an unknown client" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield false
+      end
+
+      it "does not destroy the client" do
+        engine.should_not_receive(:destroy_client)
+        server.disconnect(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => false,
+            "error"      => "401:fakeclientid:Unknown client"
+          }
+        end
+      end
+    end
+
+    describe "missing clientId" do
+      before do
+        message.delete("clientId")
+        engine.should_receive(:client_exists).with(nil).and_yield false
+      end
+
+      it "does not destroy the client" do
+        engine.should_not_receive(:destroy_client)
+        server.disconnect(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => false,
+            "error"      => "402:clientId:Missing required parameter"
+          }
+        end
+      end
+    end
+
+    describe "with an error" do
+      before do
+        message["error"] = "invalid"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+
+      it "does not destroy the client" do
+        engine.should_not_receive(:destroy_client)
+        server.disconnect(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => false,
+            "error"      => "invalid"
+          }
+        end
+      end
+    end
+  end
+end

data/spec/ruby/server/extensions_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe "server extensions" do
+  let(:engine) do
+    engine = mock "engine"
+    engine.stub(:interval).and_return(0)
+    engine.stub(:timeout).and_return(60)
+    engine
+  end
+
+  let(:server)  { Faye::Server.new }
+  let(:message) { {"channel" => "/foo", "data" => "hello"} }
+
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+
+  describe "with an incoming extension installed" do
+    before do
+      extension = Class.new do
+        def incoming(message, callback)
+          message["ext"] = {"auth" => "password"}
+          callback.call(message)
+        end
+      end
+      server.add_extension(extension.new)
+    end
+
+    it "passes incoming messages through the extension" do
+      engine.should_receive(:publish).with({"channel" => "/foo", "data" => "hello", "ext" => {"auth" => "password"}})
+      server.process(message, false) {}
+    end
+
+    it "does not pass outgoing messages through the extension" do
+      server.stub(:handshake).and_yield(message)
+      engine.stub(:publish)
+      response = nil
+      server.process({"channel" => "/meta/handshake"}, false) { |r| response = r }
+      response.should == [{"channel" => "/foo", "data" => "hello"}]
+    end
+  end
+
+  describe "with an outgoing extension installed" do
+    before do
+      extension = Class.new do
+        def outgoing(message, callback)
+          message["ext"] = {"auth" => "password"}
+          callback.call(message)
+        end
+      end
+      server.add_extension(extension.new)
+    end
+
+    it "does not pass incoming messages through the extension" do
+      engine.should_receive(:publish).with({"channel" => "/foo", "data" => "hello"})
+      server.process(message, false) {}
+    end
+
+    it "passes outgoing messages through the extension" do
+      server.stub(:handshake).and_yield(message)
+      engine.stub(:publish)
+      response = nil
+      server.process({"channel" => "/meta/handshake"}, false) { |r| response = r }
+      response.should == [{"channel" => "/foo", "data" => "hello", "ext" => {"auth" => "password"}}]
+    end
+  end
+end
+

data/spec/ruby/server/handshake_spec.rb

@@ -0,0 +1,143 @@
+require "spec_helper"
+
+describe "server handshake" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+
+  let :connection_types do
+    ["long-polling","cross-origin-long-polling","callback-polling","websocket","eventsource","in-process"]
+  end
+
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+
+  describe :handshake do
+    let(:message) {{"channel" => "/meta/handshake",
+                    "version" => "1.0",
+                    "supportedConnectionTypes" => ["long-polling"]
+                  }}
+
+    describe "with valid parameters" do
+      it "creates a client" do
+        engine.should_receive(:create_client)
+        server.handshake(message) {}
+      end
+
+      it "returns a successful response" do
+        engine.stub(:create_client).and_yield "clientid"
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => true,
+            "version"    => "1.0",
+            "supportedConnectionTypes" => connection_types,
+            "clientId"   => "clientid"
+          }
+        end
+      end
+
+      describe "with a message id" do
+        before { message["id"] = "foo" }
+
+        it "returns the same id" do
+          engine.stub(:create_client).and_yield "clientid"
+          server.handshake(message) do |response|
+            response.should == {
+              "channel"    => "/meta/handshake",
+              "successful" => true,
+              "version"    => "1.0",
+              "supportedConnectionTypes" => connection_types,
+              "clientId"   => "clientid",
+              "id"         => "foo"
+            }
+          end
+        end
+      end
+    end
+
+    describe "missing version" do
+      before { message.delete "version" }
+
+      it "does not create a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "402:version:Missing required parameter",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => connection_types
+          }
+        end
+      end
+    end
+
+    describe "missing supportedConnectionTypes" do
+      before { message.delete "supportedConnectionTypes" }
+
+      it "does not create a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "402:supportedConnectionTypes:Missing required parameter",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => connection_types
+          }
+        end
+      end
+    end
+
+    describe "with no matching supportedConnectionTypes" do
+      before { message["supportedConnectionTypes"] = ["iframe", "flash"] }
+
+      it "does not create a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "301:iframe,flash:Connection types not supported",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => connection_types
+          }
+        end
+      end
+    end
+
+    describe "with an error" do
+      before { message["error"] = "invalid" }
+
+      it "does not createa a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "invalid",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => connection_types
+          }
+        end
+      end
+    end
+  end
+end

data/spec/ruby/server/integration_spec.rb

@@ -0,0 +1,133 @@
+# encoding=utf-8
+
+require "spec_helper"
+
+require "thin"
+Thin::Logging.silent = true
+
+IntegrationSteps = EM::RSpec.async_steps do
+  class Tagger
+    def outgoing(message, callback)
+      message["data"]["tagged"] = true if message["data"]
+      callback.call(message)
+    end
+  end
+
+  def server(port, ssl, &callback)
+    shared = File.dirname(__FILE__) + '/../../../examples/shared'
+
+    options = ssl ?
+              { :key => shared + '/server.key', :cert => shared + '/server.crt' } :
+              nil
+
+    @adapter = Faye::RackAdapter.new(:mount => "/bayeux", :timeout => 25)
+    @adapter.add_extension(Tagger.new)
+    @adapter.listen(port, options)
+
+    @port = port
+    @secure = ssl
+    EM.next_tick(&callback)
+  end
+
+  def stop(&callback)
+    @adapter.stop
+    EM.next_tick(&callback)
+  end
+
+  def client(name, channels, &callback)
+    scheme = @secure ? "https" : "http"
+    @clients ||= {}
+    @inboxes ||= {}
+    @clients[name] = Faye::Client.new("#{scheme}://0.0.0.0:#{@port}/bayeux")
+    @inboxes[name] = {}
+
+    n = channels.size
+    return @clients[name].connect(&callback) if n.zero?
+
+    channels.each do |channel|
+      subscription = @clients[name].subscribe(channel) do |message|
+        @inboxes[name][channel] ||= []
+        @inboxes[name][channel] << message
+      end
+      subscription.callback do
+        n -= 1
+        callback.call if n.zero?
+      end
+    end
+  end
+
+  def publish(name, channel, message, &callback)
+    @clients[name].publish(channel, message)
+    EM.add_timer(0.1, &callback)
+  end
+
+  def check_inbox(name, channel, messages, &callback)
+    inbox = @inboxes[name][channel] || []
+    inbox.should == messages
+    callback.call
+  end
+end
+
+describe "server integration" do
+  include IntegrationSteps
+  include EncodingHelper
+
+  before do
+    server 8000, server_options[:ssl]
+    client :alice, []
+    client :bob,   ["/foo"]
+  end
+
+  after { stop }
+
+  shared_examples_for "message bus" do
+    it "delivers a message between clients" do
+      publish :alice, "/foo", {"hello" => "world", "extra" => nil}
+      check_inbox :bob, "/foo", [{"hello" => "world", "extra" => nil, "tagged" => true}]
+    end
+
+    it "does not deliver messages for unsubscribed channels" do
+      publish :alice, "/bar", {"hello" => "world"}
+      check_inbox :bob, "/foo", []
+    end
+
+    it "delivers multiple messages" do
+      publish :alice, "/foo", {"hello" => "world"}
+      publish :alice, "/foo", {"hello" => "world"}
+      check_inbox :bob, "/foo", [{"hello" => "world", "tagged" => true}, {"hello" => "world", "tagged" => true}]
+    end
+
+    it "delivers multibyte strings" do
+      publish :alice, "/foo", {"hello" => encode("Apple = "), "tagged" => true}
+      check_inbox :bob, "/foo", [{"hello" => encode("Apple = "), "tagged" => true}]
+    end
+  end
+
+  shared_examples_for "network transports" do
+    describe "with HTTP transport" do
+      before do
+        Faye::Transport::WebSocket.stub(:usable?).and_yield(false)
+      end
+
+      it_should_behave_like "message bus"
+    end
+
+    describe "with WebSocket transport" do
+      before do
+        Faye::Transport::WebSocket.stub(:usable?).and_yield(true)
+      end
+
+      it_should_behave_like "message bus"
+    end
+  end
+
+  describe "with HTTP server" do
+    let(:server_options) { {:ssl => false} }
+    it_should_behave_like "network transports"
+  end
+
+  describe "with HTTPS server" do
+    let(:server_options) { {:ssl => true} }
+    it_should_behave_like "network transports"
+  end
+end