firehose 1.3.6 → 2.1.0

data/spec/javascripts/support/spec_helper.coffee

@@ -1,3 +0,0 @@
-#= require ./jquery-1.11.1
-#= require ./json2
-#= require ./sinon-1.7.3

data/spec/lib/assets_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-require 'sprockets'
-
-describe Firehose::Assets do
-  describe ".path" do
-    it "has root path" do
-      expect(Firehose::Assets.path('poop')).to eql(File.expand_path('../../../lib/assets/poop', __FILE__))
-    end
-
-    it "accepts folders" do
-      expect(Firehose::Assets.path('poop')).to eql(File.join(Firehose::Assets.path, 'poop'))
-    end
-  end
-
-  describe "Sprockets.configure" do
-    it "configures environment" do
-      env = Firehose::Assets::Sprockets.configure Sprockets::Environment.new
-      expect(env.paths).to 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 "compiles javascript" do
-      expect(Firehose::Assets::Sprockets.javascript).to 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 "publishes message to channel" do
-    publish_stub.to_return(:body => "", :status => 202)
-
-    Firehose::Client::Producer::Http.new.publish(message).to(channel)
-    expect(WebMock).to 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 "publishes message to channel" do
-      publish_stub.to_return(:body => "", :status => 202)
-
-      Firehose::Client::Producer::Http.new(firehose_uri).publish(message).to(channel)
-      expect(WebMock).to have_requested(:put, url).with { |req| req.body == message }
-    end
-  end
-
-  it "publishes 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)
-    expect(WebMock).to have_requested(:put, url).with { |req| req.body == message and req.headers['Cache-Control'] == "max-age=#{ttl}" }
-  end
-
-  describe "connection error handling" do
-    it "raises PublishError if not 201" do
-      publish_stub.to_return(:body => "", :status => 500)
-
-      expect {
-        Firehose::Client::Producer::Http.new.publish(message).to(channel)
-      }.to raise_exception(Firehose::Client::Producer::Http::PublishError)
-    end
-
-    it "uses .error_handler if not 201" do
-      publish_stub.to_return(:body => "", :status => 500)
-
-      producer = Firehose::Client::Producer::Http.new
-      producer.on_error do |e|
-        expect(e.message).to match(/could not publish.+to/i)
-      end
-      producer.publish(message).to(channel)
-    end
-
-    it "raises TimeoutError if timed out" do
-      publish_stub.to_timeout
-
-      expect {
-        Firehose::Client::Producer::Http.new.publish(message).to(channel)
-      }.to 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 "has 7474 for default port" do
-    expect(Firehose::URI.to_s).to eql('//0.0.0.0:7474')
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'rack/test'
-require 'async_rack_test'
-
-describe Firehose::Rack::Consumer::HttpLongPoll do
-  include AsyncRackTest::Methods
-  let(:app) { Firehose::Rack::Consumer::HttpLongPoll.new }
-
-  context "transport" do
-    # Transport for Firehose::Rack::App class is tested via the spec/integrations suite.
-  end
-  context "configuration" do
-    it "has #timeout" do
-      expect(Firehose::Rack::Consumer::HttpLongPoll.new(200).timeout).to eql(200)
-    end
-  end
-
-  context "POST request" do
-    before do
-      post "/blah"
-    end
-    it "returns 405 for POST" do
-      expect(last_response.status).to eql(405)
-    end
-
-    it "specifies GET in the Allow header" do
-      expect(last_response.headers["Allow"]).to eql("GET")
-    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 "has Content-Length on OPTIONS request"
-  it "has Content-Length on GET request"
-
-  context "configuration" do
-    let(:app) { Firehose::Rack::Consumer }
-
-    it "configures long polling timeout" do
-      expect(app.new{ |a| a.http_long_poll.timeout = 300 }.http_long_poll.timeout).to eql(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 "returns 200" do
-      ahead path
-      expect(last_response.status).to eql(200)
-    end
-  end
-
-  context 'redis is not available' do
-    before { deferrable.fail 'some error' }
-    it "returns 500" do
-      ahead path
-      expect(last_response.status).to eql(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 "returns 202" do
-      app.stub(:publisher => double('publisher', :publish => deferrable))
-      aput path, :body => "some nice little message"
-      expect(last_response.status).to eql(202)
-    end
-
-    it "has Content-Length of zero" do
-      app.stub(:publisher => double('publisher', :publish => deferrable))
-      aput path, :body => "some nice little message"
-      expect(last_response.headers['Content-Length']).to eql('0')
-    end
-
-    it "parses 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 "configures long polling timeout" do
-      expect(app.new{ |a| a.consumer.http_long_poll.timeout = 300 }.consumer.http_long_poll.timeout).to eql(300)
-    end
-  end
-end

data/spec/lib/server/channel_spec.rb

@@ -1,178 +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, Firehose::Server.redis.connection, subscriber) }
-  let(:subscriber)      { Firehose::Server::Subscriber.new(Firehose::Server.redis.connection) }
-  let(:message)         { 'Raaaarrrrrr!!!!' }
-  let(:publisher)       { Firehose::Server::Publisher.new }
-
-  def push_message
-    redis_exec 'lpush', "firehose:#{channel_key}:list", message
-    redis_exec 'set', "firehose:#{channel_key}:sequence", '100'
-  end
-
-  describe "#next_messages" do
-    it "waits for message if message was not published before subscription" do
-      em do
-        channel.next_messages.callback do |messages|
-          msg = messages.first
-          expect(msg.payload).to eql(message)
-          expect(msg.sequence).to eql(1)
-          em.next_tick { em.stop }
-        end
-
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "returns the latest message and sequence if no sequence is given" do
-      push_message
-
-      em do
-        channel.next_messages.callback do |messages|
-          msg = messages.first
-          expect(msg.payload).to eql(message)
-          expect(msg.sequence).to eql(100)
-
-          # This must happen _after_ the callback runs in order to pass consistently.
-          em.next_tick { em.stop }
-        end
-      end
-    end
-
-    it "waits for message if most recent sequence is given" do
-      push_message
-
-      em 3 do
-        channel.next_messages(100).callback do |messages|
-          msg = messages.first.payload
-          seq = messages.first.sequence
-          expect(msg).to eql(message)
-          expect(seq).to eql(101)
-          em.next_tick { em.stop }
-        end.errback
-
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "waits for message if a future sequence is given" do
-      push_message
-
-      em 3 do
-        channel.next_messages(101).callback do |messages|
-          msg = messages.first.payload
-          seq = messages.first.sequence
-          expect(msg).to eql(message)
-          expect(seq).to eql(101)
-          em.next_tick { em.stop }
-        end.errback
-
-        publisher.publish(channel_key, message)
-      end
-    end
-
-    it "immediatly gets 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_messages(2).callback do |messages|
-            msg = messages.first.payload
-            seq = messages.first.sequence
-            expect(msg).to eql('c')
-            expect(seq).to eql(3)
-
-            # This must happen _after_ the callback runs in order to pass consistently.
-            em.next_tick { em.stop }
-          end
-        end
-      end
-    end
-
-    it "gets 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_messages(2).callback do |msgs|
-            msg = msgs.last.payload
-            seq = msgs.last.sequence
-            expect(msg).to eql(messages.last)
-            expect(seq).to eql(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 "times out if message isn't published in time" do
-        push_message
-
-        em 3 do
-          channel.next_messages(100, :timeout => 1).callback do |messages|
-            msg = messages.first.payload
-            seq = messages.first.sequence
-            raise 'test failed'
-          end.errback do |e|
-            expect(e).to eql(:timeout)
-            em.next_tick { em.stop }
-          end
-
-          EM::add_timer(2) do
-            publisher.publish(channel_key, message)
-          end
-        end
-      end
-
-      it "does not timeout if message is published in time" do
-        push_message
-
-        em 3 do
-          d = channel.next_messages(100, :timeout => 2).callback do |messages|
-            msg = messages.first.payload
-            seq = messages.first.sequence
-            expect(msg).to eql(message)
-            expect(seq).to eql(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/message_buffer_spec.rb

@@ -1,148 +0,0 @@
-require 'spec_helper'
-
-describe Firehose::Server::MessageBuffer do
-  it "has 100 DEFAULT_SIZE" do
-    expect(Firehose::Server::MessageBuffer::DEFAULT_SIZE).to eql(100)
-  end
-
-  subject { Firehose::Server::MessageBuffer.new(messages, channel_sequence, consumer_sequence) }
-
-  context "no messages" do
-    let(:messages) { [] }
-    let(:channel_sequence) { 0 }
-    shared_examples "empty channel" do
-      it "has empty remaining" do
-        expect(subject.remaining_messages).to be_empty
-      end
-    end
-    context "nil sequence" do
-      let(:consumer_sequence) { nil }
-      it_behaves_like "empty channel"
-    end
-    context "0 sequence" do
-      let(:consumer_sequence) { 0 }
-      it_behaves_like "empty channel"
-    end
-    context "negative sequence" do
-      let(:consumer_sequence) { -1 }
-      it_behaves_like "empty channel"
-    end
-    context "positive sequence" do
-      let(:consumer_sequence) { 100 }
-      it_behaves_like "empty channel"
-    end
-  end
-
-  context "has messages (buffer size of 5, at channel sequence 5)" do
-    let(:messages) { %w[a b c d e] }
-    let(:channel_sequence) { 5 }
-
-    shared_examples "latest message" do
-      it "returns just the latest messages" do
-        expect(subject.remaining_messages.map(&:payload)).to eql(["e"])
-      end
-      it "has the correct sequence" do
-        expect(subject.remaining_messages.map(&:sequence)).to eql([5])
-      end
-    end
-
-    context "nil sequence" do
-      let(:consumer_sequence) { nil }
-      it_behaves_like "latest message"
-    end
-    context "0 sequence" do
-      let(:consumer_sequence) { 0 }
-      it_behaves_like "latest message"
-    end
-    context "negative sequence" do
-      let(:consumer_sequence) { -1 }
-      it_behaves_like "latest message"
-    end
-
-    context "running behind" do
-      let(:consumer_sequence) { 2 }
-      it "has some remaining messages" do
-        expect(subject.remaining_messages.map(&:payload)).to eql(%w[c d e])
-      end
-      it "has the correct sequences" do
-        expect(subject.remaining_messages.map(&:sequence)).to eql((3..5).to_a)
-      end
-    end
-
-    context "caught up" do
-      let(:consumer_sequence) { 5 }
-      it "has no remaining messages" do
-        expect(subject.remaining_messages).to be_empty
-      end
-    end
-    context "ahead" do
-      let(:consumer_sequence) { 10 }
-      it "has no remaining messages" do
-        expect(subject.remaining_messages).to be_empty
-      end
-    end
-  end
-  context "has messages (buffer size of 5, at channel sequence 10)" do
-    let(:messages) { %w[f g h i j] }
-    let(:channel_sequence) { 10 }
-
-    shared_examples "latest message" do
-      it "returns just the latest messages" do
-        expect(subject.remaining_messages.map(&:payload)).to eql(["j"])
-      end
-      it "has the correct sequence" do
-        expect(subject.remaining_messages.map(&:sequence)).to eql([10])
-      end
-    end
-
-    context "nil sequence" do
-      let(:consumer_sequence) { nil }
-      it_behaves_like "latest message"
-    end
-    context "0 sequence" do
-      let(:consumer_sequence) { 0 }
-      it_behaves_like "latest message"
-    end
-    context "negative sequence" do
-      let(:consumer_sequence) { -1 }
-      it_behaves_like "latest message"
-    end
-    context "underwater" do
-      let(:consumer_sequence) { 2 }
-      it_behaves_like "latest message"
-    end
-
-    context "almost underwater" do
-      let(:consumer_sequence) { 5 }
-      it "has all remaining messages" do
-        expect(subject.remaining_messages.map(&:payload)).to eql(%w[f g h i j])
-      end
-      it "has the correct sequences" do
-        expect(subject.remaining_messages.map(&:sequence)).to eql((6..10).to_a)
-      end
-    end
-
-    context "running behind" do
-      let(:consumer_sequence) { 7 }
-      it "has some remaining messages" do
-        expect(subject.remaining_messages.map(&:payload)).to eql(%w[h i j])
-      end
-      it "has the correct sequences" do
-        expect(subject.remaining_messages.map(&:sequence)).to eql((8..10).to_a)
-      end
-    end
-
-    context "caught up" do
-      let(:consumer_sequence) { 10 }
-      it "has no remaining messages" do
-        expect(subject.remaining_messages).to be_empty
-      end
-    end
-    context "ahead" do
-      let(:consumer_sequence) { 15 }
-      it "has no remaining messages" do
-        expect(subject.remaining_messages).to be_empty
-      end
-    end
-  end
-end

data/spec/lib/server/publisher_spec.rb

@@ -1,91 +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 "has 1 day TTL" do
-    expect(Firehose::Server::Publisher::TTL).to eql(86400)
-  end
-
-  describe "#publish" do
-    it "publishes message change" do
-      em do
-        hiredis = Firehose::Server.redis.connection.pubsub
-        hiredis.subscribe "firehose:channel_updates"
-        hiredis.on(:message) {|_, msg|
-          expect(msg).to eql("#{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 "publishes 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
-        expect(redis_exec('lpop', "firehose:#{channel_key}:list")).to eql(msg)
-      end
-    end
-
-    it "adds message to list" do
-      em do
-        Firehose::Server::Publisher.new.publish(channel_key, message).callback { em.stop }
-      end
-      expect(redis_exec('lpop', "firehose:#{channel_key}:list")).to eql(message)
-    end
-
-    it "limits list to DEFAULT_SIZE messages" do
-      em do
-        Firehose::Server::MessageBuffer::DEFAULT_SIZE.times do |n|
-          publisher.publish(channel_key, message)
-        end
-        publisher.publish(channel_key, message).callback { em.stop }
-      end
-      expect(redis_exec('llen', "firehose:#{channel_key}:list")).to eql(Firehose::Server::MessageBuffer::DEFAULT_SIZE)
-    end
-
-    it "limits message list to a custom buffer size" do
-      buffer_size = rand(100)
-      em do
-        Firehose::Server::MessageBuffer::DEFAULT_SIZE.times do |n|
-          publisher.publish(channel_key, message)
-        end
-        publisher.publish(channel_key, message, buffer_size: buffer_size).callback { em.stop }
-      end
-      redis_exec('llen', "firehose:#{channel_key}:list").should == buffer_size
-    end
-
-    it "increments sequence" do
-      sequence_key = "firehose:#{channel_key}:sequence"
-
-      @done_counter = 0
-      expect(redis_exec('get', sequence_key)).to 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
-      expect(redis_exec('get', sequence_key).to_i).to eql(2)
-    end
-
-    it "sets expiry 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
-          expect(redis_exec('TTL', "firehose:#{channel_key}:sequence")).to be > (ttl- 1)
-          expect(redis_exec('TTL', "firehose:#{channel_key}:list")).to be > (ttl - 1)
-          em.stop
-        end
-      end
-    end
-
-  end
-end