faye 0.8.11 → 1.0.0

data/spec/ruby/server_spec.rb

@@ -1,121 +0,0 @@
-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 == [
-        { "successful"  => false,
-          "error"       => "405::Invalid channel"
-        },
-        { "channel"     => "invalid",
-          "successful"  => false,
-          "error"       => "405:invalid:Invalid channel"
-        }
-      ]
-    end
-
-    it "rejects unknown meta channels" do
-      response = nil
-      server.process([{"channel" => "/meta/p"}], false) { |r| response = r }
-      response.should == [
-        { "channel"     => "/meta/p",
-          "successful"  => false,
-          "error"       => "403:/meta/p:Forbidden channel"
-        }
-      ]
-    end
-
-    it "routes single messages to appropriate handlers" do
-      server.should_receive(:handshake).with(handshake, false)
-      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_not_receive(:publish).with(handshake)
-      engine.should_not_receive(:publish).with(connect)
-      engine.should_not_receive(:publish).with(disconnect)
-      engine.should_not_receive(:publish).with(subscribe)
-      engine.should_not_receive(:publish).with(unsubscribe)
-      engine.should_receive(:publish).with(publish)
-
-      server.process([handshake, connect, disconnect, subscribe, unsubscribe, publish], false)
-    end
-
-    describe "handshaking" do
-      before do
-        response = {"channel" => "/meta/handshake", "successful" => true}
-        server.should_receive(:handshake).with(handshake, false).and_yield(response)
-      end
-
-      it "returns the handshake response with advice" do
-        server.process(handshake, false) do |response|
-          response.should == [
-            { "channel" => "/meta/handshake",
-              "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
-        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

@@ -1,136 +0,0 @@
-require "spec_helper"
-
-describe Faye::Transport do
-  before do
-    Faye.ensure_reactor_running!
-  end
-
-  let :client do
-    mock("client", :endpoint => "http://example.com/", :endpoints => {}, :transports => {})
-  end
-
-  describe :get do
-    before do
-      Faye::Transport::Local.stub(:usable?).and_yield(false)
-      Faye::Transport::Http.stub(:usable?).and_yield(false)
-    end
-
-    def get_transport(connection_types)
-      transport = nil
-      Faye::Transport.get(client, connection_types, []) { |t| transport = t }
-      transport
-    end
-
-    let(:transport)       { get_transport ["long-polling", "in-process"] }
-    let(:local_transport) { get_transport ["in-process"] }
-    let(:http_transport)  { get_transport ["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_yield(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_yield(true)
-        Faye::Transport::Http.stub(:usable?).and_yield(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

@@ -1,11 +0,0 @@
-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'
-
-Faye.logger = lambda { |*| }
-
-require 'encoding_helper'
-require 'ruby/engine_examples'
-

data/spec/testswarm

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-require "rubygems"
-require "bundler/setup"
-require "testswarm/client"
-
-server  = ENV["TESTSWARM_SERVER"]
-key     = ENV["TESTSWARM_KEY"]
-root    = ENV["TESTSWARM_ROOT"]
-bundle  = ENV["BUNDLE_DIRECTORY"]
-
-client  = TestSwarm::Client.new(server)
-project = client.project("faye", :auth => key)
-
-job = TestSwarm::Job.create(
-  :rcs        => {
-    :type     => "git",
-    :url      => "git://github.com/faye/faye.git",
-    :branch   => "master"
-  },
-  :directory  => File.join(root, "changeset", project.name),
-  :diff       => ["javascript", "spec/javascript"],
-  :build      => [
-                   "mkdir -p vendor",
-                   "ln -s #{bundle} vendor/bundle",
-                   "bundle install --path vendor/bundle",
-                   "npm install",
-                   "rm -rf build",
-                   "bundle exec jake"
-                 ],
-  :inject     => "spec/browser.html"
-)
-
-exit unless job.new?
-
-path = "#{client.url}/changeset/#{project.name}/#{job.revision}"
-job.add_suite "Faye tests", "#{path}/spec/browser.html"
-
-project.submit_job "Faye Commit #{job.revision}", job,
-                   :browsers => "all",
-                   :max      => 5
-

data/spec/thin_proxy.rb

@@ -1,37 +0,0 @@
-require 'rack/proxy'
-
-# This only exists so we can use Rack::Test to test the
-# RackAdapter class, which assumes it's running on Thin
-
-class ThinProxy < Rack::Proxy
-  HOST = 'localhost'
-  PORT = '8282'
-
-  def initialize(rack_app)
-    Thin::Logging.silent = true
-    handler = Rack::Handler.get('thin')
-
-    EM.stop if EM.reactor_running?
-    Thread.pass while EM.reactor_running?
-
-    Thread.new {
-      handler.run(rack_app, :Host => HOST, :Port => PORT) do |server|
-        @server = server
-      end
-    }
-    Thread.pass until EM.reactor_running?
-  end
-
-  def stop
-    EM.stop
-    @server.stop
-    Thread.pass while EM.reactor_running?
-  end
-
-  def rewrite_env(env)
-    env['HTTP_HOST'] = HOST
-    env['SERVER_PORT'] = PORT
-    env[Faye::RackAdapter::HTTP_X_NO_CONTENT_LENGTH] = '1'
-    env
-  end
-end