firehose 1.2.20 → 1.3.6

data/spec/javascripts/support/spec_helper.coffee

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

data/spec/lib/assets_spec.rb

@@ -3,19 +3,19 @@ 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__)
+    it "has root path" do
+      expect(Firehose::Assets.path('poop')).to eql(File.expand_path('../../../lib/assets/poop', __FILE__))
     end
 
-    it "should accept folders" do
-      Firehose::Assets.path('poop').should == File.join(Firehose::Assets.path, 'poop')
+    it "accepts folders" do
+      expect(Firehose::Assets.path('poop')).to eql(File.join(Firehose::Assets.path, 'poop'))
     end
   end
 
   describe "Sprockets.configure" do
-    it "should configure environment" do
+    it "configures environment" do
       env = Firehose::Assets::Sprockets.configure Sprockets::Environment.new
-      env.paths.should include(Firehose::Assets.path('javascripts'))
+      expect(env.paths).to include(Firehose::Assets.path('javascripts'))
     end
   end
 
@@ -28,8 +28,8 @@ describe Firehose::Assets do
         "window.Firehose || (window.Firehose = {})"
       ]
     end
-    it "should compile javascript" do
-      Firehose::Assets::Sprockets.javascript.should include(*js_spot_checks)
+    it "compiles javascript" do
+      expect(Firehose::Assets::Sprockets.javascript).to include(*js_spot_checks)
     end
   end
 end

data/spec/lib/client/producer_spec.rb

@@ -14,58 +14,58 @@ describe Firehose::Client::Producer::Http do
     Firehose::Client::Producer::Http.adapter = nil
   end
 
-  it "should publish message to channel" do
+  it "publishes 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 }
+    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 "should publish message to channel" do
+    it "publishes 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 }
+      expect(WebMock).to have_requested(:put, url).with { |req| req.body == message }
     end
   end
 
-  it "should publish message to channel with expiry headers" do
+  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)
-    WebMock.should have_requested(:put, url).with { |req| req.body == message and req.headers['Cache-Control'] == "max-age=#{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 "should raise PublishError if not 201" do
+    it "raises PublishError if not 201" do
       publish_stub.to_return(:body => "", :status => 500)
 
-      lambda{
+      expect {
         Firehose::Client::Producer::Http.new.publish(message).to(channel)
-      }.should raise_exception(Firehose::Client::Producer::Http::PublishError)
+      }.to raise_exception(Firehose::Client::Producer::Http::PublishError)
     end
 
-    it "should use .error_handler if not 201" do
+    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|
-        e.message.should =~ /could not publish.+to/i
+        expect(e.message).to match(/could not publish.+to/i)
       end
       producer.publish(message).to(channel)
     end
 
-    it "should raise TimeoutError if timed out" do
+    it "raises TimeoutError if timed out" do
       publish_stub.to_timeout
 
-      lambda{
+      expect {
         Firehose::Client::Producer::Http.new.publish(message).to(channel)
-      }.should raise_exception(Firehose::Client::Producer::Http::TimeoutError)
+      }.to raise_exception(Firehose::Client::Producer::Http::TimeoutError)
     end
   end
 end

data/spec/lib/firehose_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Firehose do
-  it "should have 7474 for default port" do
-    Firehose::URI.to_s.should == '//0.0.0.0:7474'
+  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,12 +1,30 @@
 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 "should have #timeout" do
-      Firehose::Rack::Consumer::HttpLongPoll.new(200).timeout.should == 200
+    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
+end

data/spec/lib/rack/consumer_spec.rb

@@ -6,14 +6,14 @@ describe Firehose::Rack::Consumer, :type => :request do
   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"
+  it "has Content-Length on OPTIONS request"
+  it "has 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
+    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

@@ -12,17 +12,17 @@ describe Firehose::Rack::Ping, :type => :request do
   context 'redis is available' do
     before { deferrable.succeed Firehose::Rack::Ping::PingCheck::TEST_VALUE }
 
-    it "should return 200" do
+    it "returns 200" do
       ahead path
-      last_response.status.should == 200
+      expect(last_response.status).to eql(200)
     end
   end
 
   context 'redis is not available' do
     before { deferrable.fail 'some error' }
-    it "should return 500" do
+    it "returns 500" do
       ahead path
-      last_response.status.should == 500
+      expect(last_response.status).to eql(500)
     end
   end
 end

data/spec/lib/rack/publisher_spec.rb

@@ -11,19 +11,19 @@ describe Firehose::Rack::Publisher, :type => :request do
   context 'publishing is successful' do
     before { deferrable.succeed }
 
-    it "should return 202" do
+    it "returns 202" do
       app.stub(:publisher => double('publisher', :publish => deferrable))
       aput path, :body => "some nice little message"
-      last_response.status.should == 202
+      expect(last_response.status).to eql(202)
     end
 
-    it "should have Content-Length of zero" do
+    it "has 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'
+      expect(last_response.headers['Content-Length']).to eql('0')
     end
 
-    it "should parse Cache-Control max-age" do
+    it "parses Cache-Control max-age" do
       body = "howdy dude!"
       ttl = '92'
 

data/spec/lib/server/app_spec.rb

@@ -8,8 +8,8 @@ describe Firehose::Rack::App do
   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
+    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

@@ -4,17 +4,23 @@ 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(: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 }
 
-  describe "#next_message" do
-    it "should wait for message if message was not published before subscription" do
+  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_message.callback do |msg, seq|
-          msg.should == message
-          seq.should == 1
+        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
 
@@ -22,14 +28,14 @@ describe Firehose::Server::Channel do
       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'
+    it "returns the latest message and sequence if no sequence is given" do
+      push_message
 
       em do
-        channel.next_message.callback do |msg, seq|
-          msg.should == message
-          seq.should == 100
+        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 }
@@ -37,14 +43,15 @@ describe Firehose::Server::Channel do
       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'
+    it "waits for message if most recent sequence is given" do
+      push_message
 
       em 3 do
-        channel.next_message(100).callback do |msg, seq|
-          msg.should == message
-          seq.should == 101
+        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
 
@@ -52,14 +59,15 @@ describe Firehose::Server::Channel do
       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'
+    it "waits for message if a future sequence is given" do
+      push_message
 
       em 3 do
-        channel.next_message(101).callback do |msg, seq|
-          msg.should == message
-          seq.should == 101
+        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
 
@@ -67,14 +75,16 @@ describe Firehose::Server::Channel do
       end
     end
 
-    it "should immediatly get a message if message sequence is behind and in list" do
+    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_message(2).callback do |msg, seq|
-            msg.should == 'c'
-            seq.should == 3
+          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 }
@@ -83,14 +93,16 @@ describe Firehose::Server::Channel do
       end
     end
 
-    it "should get current message if sequence is really far behind in list" do
+    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_message(2).callback do |msg, seq|
-            msg.should == messages.last
-            seq.should == messages.size
+          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 }
@@ -100,15 +112,16 @@ describe Firehose::Server::Channel do
     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'
+      it "times out if message isn't published in time" do
+        push_message
 
         em 3 do
-          channel.next_message(100, :timeout => 1).callback do |msg, seq|
+          channel.next_messages(100, :timeout => 1).callback do |messages|
+            msg = messages.first.payload
+            seq = messages.first.sequence
             raise 'test failed'
           end.errback do |e|
-            e.should == :timeout
+            expect(e).to eql(:timeout)
             em.next_tick { em.stop }
           end
 
@@ -118,14 +131,15 @@ describe Firehose::Server::Channel do
         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'
+      it "does not timeout if message is published in time" do
+        push_message
 
         em 3 do
-          d = channel.next_message(100, :timeout => 2).callback do |msg, seq|
-            msg.should == message
-            seq.should == 101
+          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

data/spec/lib/server/message_buffer_spec.rb

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