faye 0.8.11 → 1.0.0

data/spec/ruby/server/disconnect_spec.rb

@@ -1,120 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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

@@ -1,133 +0,0 @@
-# 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