firehose 1.2.20 → 2.1.0

data/spec/lib/assets_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-require 'sprockets'
-
-describe Firehose::Assets do
-  describe ".path" do
-    it "should have root path" do
-      Firehose::Assets.path('poop').should == File.expand_path('../../../lib/assets/poop', __FILE__)
-    end
-
-    it "should accept folders" do
-      Firehose::Assets.path('poop').should == File.join(Firehose::Assets.path, 'poop')
-    end
-  end
-
-  describe "Sprockets.configure" do
-    it "should configure environment" do
-      env = Firehose::Assets::Sprockets.configure Sprockets::Environment.new
-      env.paths.should include(Firehose::Assets.path('javascripts'))
-    end
-  end
-
-  describe "Sprockets.javascript" do
-    let(:js_spot_checks) do
-      [
-        "Firehose.Transport",
-        "Firehose.version",
-        "global.Firehose || (global.Firehose = {})",
-        "window.Firehose || (window.Firehose = {})"
-      ]
-    end
-    it "should compile javascript" do
-      Firehose::Assets::Sprockets.javascript.should include(*js_spot_checks)
-    end
-  end
-end

data/spec/lib/client/consumer_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Client::Consumer::WebSocket do
-  context "transport" do
-    # Transport for Firehose::Client::App class is tested via the spec/integrations suite.
-  end
-end
-
-describe Firehose::Client::Consumer::HttpLongPoll do
-  context "transport" do
-    # Transport for Firehose::Client::App class is tested via the spec/integrations suite.
-  end
-end

data/spec/lib/client/producer_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Client::Producer::Http do
-  let(:channel)       { "/channel-awesome" }
-  let(:url)           { "#{Firehose::URI}#{channel}"}
-  let(:publish_stub)  { stub_request(:put, url) }
-  let(:message)       { "hey dude" }
-
-  before(:all) do
-    Firehose::Client::Producer::Http.adapter = :net_http
-  end
-
-  after(:all) do
-    Firehose::Client::Producer::Http.adapter = nil
-  end
-
-  it "should publish message to channel" do
-    publish_stub.to_return(:body => "", :status => 202)
-
-    Firehose::Client::Producer::Http.new.publish(message).to(channel)
-    WebMock.should have_requested(:put, url).with { |req| req.body == message }
-  end
-
-  context 'prefix is specified in URI' do
-    let(:firehose_uri) {"#{Firehose::URI}/prefix"}
-    let(:url) { "#{firehose_uri}#{channel}"}
-
-    it "should publish message to channel" do
-      publish_stub.to_return(:body => "", :status => 202)
-
-      Firehose::Client::Producer::Http.new(firehose_uri).publish(message).to(channel)
-      WebMock.should have_requested(:put, url).with { |req| req.body == message }
-    end
-  end
-
-  it "should publish message to channel with expiry headers" do
-    publish_stub.to_return(:body => "", :status => 202)
-    ttl = 20
-
-    Firehose::Client::Producer::Http.new.publish(message).to(channel, :ttl => ttl)
-    WebMock.should have_requested(:put, url).with { |req| req.body == message and req.headers['Cache-Control'] == "max-age=#{ttl}" }
-  end
-
-  describe "connection error handling" do
-    it "should raise PublishError if not 201" do
-      publish_stub.to_return(:body => "", :status => 500)
-
-      lambda{
-        Firehose::Client::Producer::Http.new.publish(message).to(channel)
-      }.should raise_exception(Firehose::Client::Producer::Http::PublishError)
-    end
-
-    it "should use .error_handler if not 201" do
-      publish_stub.to_return(:body => "", :status => 500)
-
-      producer = Firehose::Client::Producer::Http.new
-      producer.on_error do |e|
-        e.message.should =~ /could not publish.+to/i
-      end
-      producer.publish(message).to(channel)
-    end
-
-    it "should raise TimeoutError if timed out" do
-      publish_stub.to_timeout
-
-      lambda{
-        Firehose::Client::Producer::Http.new.publish(message).to(channel)
-      }.should raise_exception(Firehose::Client::Producer::Http::TimeoutError)
-    end
-  end
-end

data/spec/lib/firehose_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Firehose do
-  it "should have 7474 for default port" do
-    Firehose::URI.to_s.should == '//0.0.0.0:7474'
-  end
-end

data/spec/lib/rack/consumer/http_long_poll_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Rack::Consumer::HttpLongPoll do
-  context "transport" do
-    # Transport for Firehose::Rack::App class is tested via the spec/integrations suite.
-  end
-  context "configuration" do
-    it "should have #timeout" do
-      Firehose::Rack::Consumer::HttpLongPoll.new(200).timeout.should == 200
-    end
-  end
-end

data/spec/lib/rack/consumer_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'rack/test'
-
-describe Firehose::Rack::Consumer, :type => :request do
-  include Rack::Test::Methods
-  let(:app) { Firehose::Rack::Consumer.new }
-  let(:path) { "/test/path/#{Time.now.to_i}" }
-
-  it "should have Content-Length on OPTIONS request"
-  it "should have Content-Length on GET request"
-
-  context "configuration" do
-    let(:app) { Firehose::Rack::Consumer }
-
-    it "should configure long polling timeout" do
-      app.new{ |a| a.http_long_poll.timeout = 300 }.http_long_poll.timeout.should == 300
-    end
-  end
-end

data/spec/lib/rack/ping_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'rack/test'
-require 'async_rack_test'
-
-describe Firehose::Rack::Ping, :type => :request do
-  include AsyncRackTest::Methods
-  let(:app) { Firehose::Rack::Ping.new dummy_redis }
-  let(:path) { "/test/path/#{Time.now.to_i}" }
-  let(:deferrable) { EM::DefaultDeferrable.new }
-  let(:dummy_redis) { double 'redis', :set => deferrable, :get => deferrable, :expire => deferrable }
-
-  context 'redis is available' do
-    before { deferrable.succeed Firehose::Rack::Ping::PingCheck::TEST_VALUE }
-
-    it "should return 200" do
-      ahead path
-      last_response.status.should == 200
-    end
-  end
-
-  context 'redis is not available' do
-    before { deferrable.fail 'some error' }
-    it "should return 500" do
-      ahead path
-      last_response.status.should == 500
-    end
-  end
-end

data/spec/lib/rack/publisher_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'rack/test'
-require 'async_rack_test'
-
-describe Firehose::Rack::Publisher, :type => :request do
-  include AsyncRackTest::Methods
-  let(:app) { Firehose::Rack::Publisher.new }
-  let(:path) { "/test/path/#{Time.now.to_i}" }
-  let(:deferrable) { EM::DefaultDeferrable.new }
-
-  context 'publishing is successful' do
-    before { deferrable.succeed }
-
-    it "should return 202" do
-      app.stub(:publisher => double('publisher', :publish => deferrable))
-      aput path, :body => "some nice little message"
-      last_response.status.should == 202
-    end
-
-    it "should have Content-Length of zero" do
-      app.stub(:publisher => double('publisher', :publish => deferrable))
-      aput path, :body => "some nice little message"
-      last_response.headers['Content-Length'].should == '0'
-    end
-
-    it "should parse Cache-Control max-age" do
-      body = "howdy dude!"
-      ttl = '92'
-
-      Firehose::Server::Publisher.any_instance.stub(:publish).with(path, body, :ttl => ttl).and_return(deferrable)
-      aput path, body, 'HTTP_CACHE_CONTROL' => 'max-age=92'
-    end
-  end
-end

data/spec/lib/server/app_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Rack::App do
-  context "transport" do
-    # Transport for Firehose::Rack::App class is tested via the spec/integrations suite.
-  end
-
-  context "configuration" do
-    let(:app) { Firehose::Rack::App }
-
-    it "should configure long polling timeout" do
-      app.new{ |a| a.consumer.http_long_poll.timeout = 300 }.consumer.http_long_poll.timeout.should == 300
-    end
-  end
-end

data/spec/lib/server/channel_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Server::Channel do
-  include EM::TestHelper
-
-  let(:channel_key)     { '/bears/are/mean' }
-  let(:channel)         { Firehose::Server::Channel.new(channel_key, EM::Hiredis.connect, subscriber) }
-  let(:subscriber)      { Firehose::Server::Subscriber.new(EM::Hiredis.connect) }
-  let(:message)         { 'Raaaarrrrrr!!!!' }
-  let(:publisher)       { Firehose::Server::Publisher.new }
-
-  describe "#next_message" do
-    it "should wait for message if message was not published before subscription" do
-      em do
-        channel.next_message.callback do |msg, seq|
-          msg.should == message
-          seq.should == 1
-          em.next_tick { em.stop }
-        end
-
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "should return the latest message and sequence if no sequence is given" do
-      redis_exec 'lpush', "firehose:#{channel_key}:list", message
-      redis_exec 'set', "firehose:#{channel_key}:sequence", '100'
-
-      em do
-        channel.next_message.callback do |msg, seq|
-          msg.should == message
-          seq.should == 100
-
-          # This must happen _after_ the callback runs in order to pass consistently.
-          em.next_tick { em.stop }
-        end
-      end
-    end
-
-    it "should wait for message if most recent sequence is given" do
-      redis_exec 'lpush', "firehose:#{channel_key}:list", message
-      redis_exec 'set', "firehose:#{channel_key}:sequence", '100'
-
-      em 3 do
-        channel.next_message(100).callback do |msg, seq|
-          msg.should == message
-          seq.should == 101
-          em.next_tick { em.stop }
-        end.errback
-
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "should wait for message if a future sequence is given" do
-      redis_exec 'lpush', "firehose:#{channel_key}:list", message
-      redis_exec 'set', "firehose:#{channel_key}:sequence", '100'
-
-      em 3 do
-        channel.next_message(101).callback do |msg, seq|
-          msg.should == message
-          seq.should == 101
-          em.next_tick { em.stop }
-        end.errback
-
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "should immediatly get a message if message sequence is behind and in list" do
-      messages = %w[a b c d e]
-
-      em 3 do
-        publish_messages(messages) do
-          channel.next_message(2).callback do |msg, seq|
-            msg.should == 'c'
-            seq.should == 3
-
-            # This must happen _after_ the callback runs in order to pass consistently.
-            em.next_tick { em.stop }
-          end
-        end
-      end
-    end
-
-    it "should get current message if sequence is really far behind in list" do
-      messages = ('aa'..'zz').to_a
-
-      em 3 do
-        publish_messages(messages) do
-          channel.next_message(2).callback do |msg, seq|
-            msg.should == messages.last
-            seq.should == messages.size
-
-            # This must happen _after_ the callback runs in order to pass consistently.
-            em.next_tick { em.stop }
-          end
-        end
-      end
-    end
-
-    context "a timeout is set" do
-      it "should timeout if message isn't published in time" do
-        redis_exec 'lpush', "firehose:#{channel_key}:list", message
-        redis_exec 'set', "firehose:#{channel_key}:sequence", '100'
-
-        em 3 do
-          channel.next_message(100, :timeout => 1).callback do |msg, seq|
-            raise 'test failed'
-          end.errback do |e|
-            e.should == :timeout
-            em.next_tick { em.stop }
-          end
-
-          EM::add_timer(2) do
-            publisher.publish(channel_key, message)
-          end
-        end
-      end
-
-      it "should not timeout if message is published in time" do
-        redis_exec 'lpush', "firehose:#{channel_key}:list", message
-        redis_exec 'set', "firehose:#{channel_key}:sequence", '100'
-
-        em 3 do
-          d = channel.next_message(100, :timeout => 2).callback do |msg, seq|
-            msg.should == message
-            seq.should == 101
-            EM::add_timer(1) do
-              em.stop
-            end
-          end.errback do |e|
-            raise 'test failed'
-          end
-
-          d.should_not_receive(:fail)
-
-          EM::add_timer(1) do
-            publisher.publish(channel_key, message)
-          end
-        end
-      end
-    end
-  end
-
-
-  # Publishes the given messages and executes the given block when finished.
-  def publish_messages(all_messages)
-    publish = Proc.new do |messages_to_publish|
-      msg = messages_to_publish.shift
-      publisher.publish(channel_key, msg).callback do
-        if messages_to_publish.empty?
-          # Publishing is done, proceed with the test
-          yield
-        else
-          # Publish the next message
-          publish.call messages_to_publish
-        end
-      end
-    end
-
-    publish.call all_messages.dup
-  end
-end

data/spec/lib/server/publisher_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Server::Publisher do
-  include EM::TestHelper
-
-  let(:publisher)   { Firehose::Server::Publisher.new }
-  let(:channel_key) { "/firehose/publisher/test/#{Time.now.to_i}" }
-  let(:message)     { "howdy friends!" }
-
-  it "should have 100 MAX_MESSAGES" do
-    Firehose::Server::Publisher::MAX_MESSAGES.should == 100
-  end
-
-  it "should have 1 day TTL" do
-    Firehose::Server::Publisher::TTL.should == 86400
-  end
-
-  describe "#publish" do
-    it "should publish message change" do
-      em do
-        hiredis = EM::Hiredis.connect.pubsub
-        hiredis.subscribe "firehose:channel_updates"
-        hiredis.on(:message) {|_, msg|
-          msg.should == "#{channel_key}\n1\n#{message}"
-          em.next_tick { em.stop }
-        }
-        Firehose::Server::Publisher.new.publish channel_key, message
-      end
-    end
-
-    "\"'\r\t\n!@\#$%^&*()[]\v\f\a\b\e{}/=?+\\|".each_char do |char|
-      it "should publish messages with the '#{char.inspect}' character" do
-        msg = [char, message, char].join
-        em 1 do
-          Firehose::Server::Publisher.new.publish(channel_key, msg).callback { em.stop }
-        end
-        redis_exec('lpop', "firehose:#{channel_key}:list").should == msg
-      end
-    end
-
-    it "should add message to list" do
-      em do
-        Firehose::Server::Publisher.new.publish(channel_key, message).callback { em.stop }
-      end
-      redis_exec('lpop', "firehose:#{channel_key}:list").should == message
-    end
-
-    it "should limit list to MAX_MESSAGES messages" do
-      em do
-        Firehose::Server::Publisher::MAX_MESSAGES.times do |n|
-          publisher.publish(channel_key, message)
-        end
-        publisher.publish(channel_key, message).callback { em.stop }
-      end
-      redis_exec('llen', "firehose:#{channel_key}:list").should == Firehose::Server::Publisher::MAX_MESSAGES
-    end
-
-    it "should increment sequence" do
-      sequence_key = "firehose:#{channel_key}:sequence"
-
-      @done_counter = 0
-      redis_exec('get', sequence_key).should be_nil
-      em do
-        publisher.publish(channel_key, message).callback { @done_counter += 1; em.next_tick { em.stop } if @done_counter > 1 }
-        publisher.publish(channel_key, message).callback { @done_counter += 1; em.next_tick { em.stop } if @done_counter > 1 }
-      end
-      redis_exec('get', sequence_key).to_i.should == 2
-    end
-
-    it "should set expirery on sequence and list keys" do
-      ttl = 78 # Why 78? Why not!
-
-      em do
-        publisher.publish(channel_key, message, :ttl => 78).callback do
-          # Allow for 1 second of slippage/delay
-          redis_exec('TTL', "firehose:#{channel_key}:sequence").should > (ttl- 1)
-          redis_exec('TTL', "firehose:#{channel_key}:list").should > (ttl - 1)
-          em.stop
-        end
-      end
-    end
-
-  end
-end

data/spec/lib/server/subscriber_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Server::Subscriber do
-  include EM::TestHelper
-
-  let(:channel_key)     { '/bears/are/mean' }
-  let(:subscriber)      { Firehose::Server::Subscriber.new(EM::Hiredis.connect) }
-  let(:dummy_subscriber){ Firehose::Server::Subscriber.new(double('redis', :pubsub => double('pubsub', :subscribe => EM::DefaultDeferrable.new, :on => nil))) }
-  let(:message)         { 'Raaaarrrrrr!!!!' }
-  let(:publisher)       { Firehose::Server::Publisher.new }
-
-  describe "#subscribe" do
-    it "should add the deferrable to the subscriptions hash" do
-      deferrable = EM::DefaultDeferrable.new
-      dummy_subscriber.subscribe(channel_key, deferrable)
-      dummy_subscriber.send(:subscriptions)[channel_key].should == [deferrable]
-    end
-
-    it "should call succeed on the deferrable when a message is published" do
-      deferrable = EM::DefaultDeferrable.new
-      deferrable.callback do |msg, sequence|
-        msg.should == message
-        sequence.should == 1 # The publisher is fresh, so the sequence ID will be 1.
-        em.next_tick { em.stop }
-      end
-
-      em do
-        subscriber.subscribe(channel_key, deferrable)
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "shouldn't call succeed on the deferrable when a 2nd message is published" do
-      deferrable = EM::DefaultDeferrable.new
-      deferrable.should_receive(:succeed).with(message, 1) # The publisher is fresh, so the sequence ID will be 1.
-      deferrable.should_not_receive(:succeed).with('2nd message', 2)
-      em do
-        subscriber.subscribe(channel_key, deferrable)
-        publisher.publish(channel_key, message).callback do
-          publisher.publish(channel_key, '2nd message').callback do
-            em.stop
-          end
-        end
-      end
-
-    end
-  end
-
-  describe "#unsubscribe" do
-    it "should remove the deferrable from the subscriptions hash" do
-      deferrable = EM::DefaultDeferrable.new
-      dummy_subscriber.subscribe(channel_key, deferrable)
-      dummy_subscriber.unsubscribe(channel_key, deferrable)
-      dummy_subscriber.send(:subscriptions).has_key?(channel_key).should be_false
-    end
-
-    it "shouldn't call succeed on the deferrable when a message is published" do
-      deferrable = EM::DefaultDeferrable.new
-      deferrable.should_not_receive(:succeed).with(message, 1) # The publisher is fresh, so the sequence ID will be 1.
-      em do
-        subscriber.subscribe(channel_key, deferrable)
-        subscriber.unsubscribe(channel_key, deferrable)
-        publisher.publish(channel_key, message).callback do
-          em.stop
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,77 +0,0 @@
-ENV['RACK_ENV'] ||= 'test'
-
-require 'logger'
-require 'em-http'
-require 'faye/websocket'
-require 'hiredis'
-require 'firehose'
-
-# We use both EM::Http and Net::Http in this test lib. When EM:Http is fired up
-# we're usually hitting Rainbows! for integrations, and when Net::Http we want
-# to mock that up.
-require 'webmock/rspec'
-WebMock.allow_net_connect!
-
-module EM::TestHelper
-  # Run test inside of reactor.
-  def em(ttl=30, &block)
-    if block
-      # Run the block inside of a reactor
-      EM.run do
-        EM.add_timer(ttl) do
-          EM.stop
-          raise "Test timed-out"
-        end
-        block.call(EM)
-      end
-    else # or just grab em and go nuts.
-      EM
-    end
-  end
-end
-
-module Hiredis::TestHelper
-  def redis
-    @conn ||= begin
-      conn = Hiredis::Connection.new
-      conn.connect("127.0.0.1", 6379)
-      conn
-    end
-  end
-
-  def reset_redis
-    redis_exec 'flushdb'
-  end
-
-  def redis_exec(*tokens)
-    redis.write tokens
-    redis.read
-  end
-end
-
-# Configure RSpec runner. See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-  config.include Hiredis::TestHelper
-  config.before(:each) do
-    reset_redis
-  end
-end
-
-# Allow async responses to get through rack/lint
-require 'rack/lint'
-class Rack::Lint
-  def check_status_with_async(status)
-    check_status_without_async(status) unless status == -1
-  end
-  alias_method :check_status_without_async, :check_status
-  alias_method :check_status, :check_status_with_async
-
-  def check_content_type_with_async(status, headers)
-    check_content_type_without_async(status, headers) unless status == -1
-  end
-  alias_method :check_content_type_without_async, :check_content_type
-  alias_method :check_content_type, :check_content_type_with_async
-end