faye 0.8.11 → 1.0.0

data/spec/ruby/engine/memory_spec.rb

@@ -1,7 +0,0 @@
-require "spec_helper"
-
-describe Faye::Engine::Memory do
-  let(:engine_opts)  { {:type => Faye::Engine::Memory} }
-  it_should_behave_like "faye engine"
-end
-

data/spec/ruby/engine_examples.rb

@@ -1,427 +0,0 @@
-# encoding=utf-8
-
-root = File.expand_path('../../..', __FILE__)
-
-require root + '/vendor/em-rspec/lib/em-rspec'
-require root + '/spec/encoding_helper'
-
-require root + '/lib/faye/mixins/logging'
-require root + '/lib/faye/mixins/publisher'
-require root + '/lib/faye/mixins/timeouts'
-
-require root + '/lib/faye/protocol/channel'
-require root + '/lib/faye/protocol/grammar'
-require root + '/lib/faye/engines/proxy'
-
-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::Engine.random}.merge(message)
-      engine.publish(message)
-    end
-    EM.add_timer(0.01, &resume)
-  end
-
-  def publish_by(name, message, &resume)
-    message = {"clientId" => @clients[name], "id" => Faye::Engine.random}.merge(message)
-    engine.publish(message)
-    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_event(name, event, args, &resume)
-    params  = [@clients[name]] + args
-    handler = lambda { |*a| }
-    engine.bind(event, &handler)
-    handler.should_receive(:call).with(*params)
-    resume.call
-  end
-
-  def expect_no_event(name, event, args, &resume)
-    params  = [@clients[name]] + args
-    handler = lambda { |*a| }
-    engine.bind(event, &handler)
-    handler.should_not_receive(:call).with(*params)
-    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 check_different_messages(a, b, &resume)
-    @inboxes[a].first.should_not be_equal(@inboxes[b].first)
-    resume.call
-  end
-end
-
-describe "Pub/sub engines" do
-  shared_examples_for "faye engine" do
-    include EncodingHelper
-    include EngineSteps
-
-    def create_engine
-      opts = options.merge(engine_opts)
-      Faye::Engine::Proxy.new(opts)
-    end
-
-    let(:options) { {:timeout => 1} }
-    let(:engine) { create_engine }
-
-    before do
-      Faye.stub(:logger)
-      Faye::Engine.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
-
-      it "publishes an event" do
-        engine.should_receive(:trigger).with(:handshake, match(/^[a-z0-9]+$/)).exactly(4)
-        create_client :dave
-      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
-
-      it "publishes an event" do
-        expect_event :alice, :disconnect, []
-        destroy_client :alice
-      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
-
-        it "publishes an event" do
-          expect_event :alice, :disconnect, []
-          destroy_client :alice
-        end
-      end
-    end
-
-    describe :subscribe do
-      it "publishes an event" do
-        expect_event :alice, :subscribe, ["/messages/foo"]
-        subscribe :alice, "/messages/foo"
-      end
-
-      describe "when the client is subscribed to the channel" do
-        before { subscribe :alice, "/messages/foo" }
-
-        it "does not publish an event" do
-          expect_no_event :alice, :subscribe, ["/messages/foo"]
-          subscribe :alice, "/messages/foo"
-        end
-      end
-    end
-
-    describe :unsubscribe do
-      before { subscribe :alice, "/messages/bar" }
-
-      it "does not publish an event" do
-        expect_no_event :alice, :unsubscribe, ["/messages/foo"]
-        unsubscribe :alice, "/messages/foo"
-      end
-
-      describe "when the client is subscribed to the channel" do
-        before { subscribe :alice, "/messages/foo" }
-
-        it "publishes an event" do
-          expect_event :alice, :unsubscribe, ["/messages/foo"]
-          unsubscribe :alice, "/messages/foo"
-        end
-      end
-    end
-
-    describe :publish do
-      before do
-        @message = {"channel" => "/messages/foo", "data" => "ok", "blank" => nil}
-        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
-
-        it "publishes a :publish event with a clientId" do
-          expect_event :bob, :publish, ["/messages/foo", "ok"]
-          publish_by :bob, @message
-        end
-
-        it "publishes a :publish event with no clientId" do
-          expect_event nil, :publish, ["/messages/foo", "ok"]
-          publish @message
-        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
-
-        it "delivers multibyte messages correctly" do
-          @message["data"] = encode "Apple = "
-          publish @message
-          expect_message :alice, [@message]
-        end
-
-        it "publishes a :publish event" do
-          expect_event :bob, :publish, ["/messages/foo", "ok"]
-          publish_by :bob, @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
-
-        it "publishes a :publish event" do
-          expect_event :bob, :publish, ["/messages/foo", "ok"]
-          publish_by :bob, @message
-        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
-
-        it "delivers a unique copy of the message to each client" do
-          publish @message
-          check_different_messages :alice, :carol
-        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
-
-    def create_engine
-      opts = options.merge(engine_opts)
-      Faye::Engine::Proxy.new(opts)
-    end
-
-    let(:options) { {} }
-    let(:left)  { create_engine }
-    let(:right) { create_engine }
-
-    alias :engine :left
-
-    before do
-      Faye.stub(:logger)
-      Faye::Engine.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
-end
-

data/spec/ruby/faye_spec.rb

@@ -1,30 +0,0 @@
-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 == 31 }
-    end
-  end
-
-  describe :copy_obect do
-    let(:object) { {"foo" => "bar", "qux" => 42, "hey" => nil, "obj" => {"bar" => 67}} }
-
-    it "returns an equal object" do
-      Faye.copy_object(object).should == {"foo" => "bar", "qux" => 42, "hey" => nil, "obj" => {"bar" => 67}}
-    end
-
-    it "does not return the same object" do
-      Faye.copy_object(object).should_not be_equal(object)
-    end
-
-    it "performs a deep clone" do
-      Faye.copy_object(object)["obj"].should_not be_equal(object["obj"])
-    end
-  end
-end