firehose 0.1.1 → 0.2.alpha.2

data/spec/lib/channel_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe Firehose::Channel do
+  include EM::TestHelper
+
+  let(:channel_key)     { '/bears/are/mean' }
+  let(:channel)         { Firehose::Channel.new(channel_key, EM::Hiredis.connect, subscriber) }
+  let(:subscriber)      { Firehose::Subscriber.new(EM::Hiredis.connect) }
+  let(:message)         { 'Raaaarrrrrr!!!!' }
+  let(:publisher)       { Firehose::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/client_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Firehose::Client::Consumer::WebSocket do
+  it "should be tested" # probably inside of the integrations
+end
+
+describe Firehose::Client::Consumer::HttpLongPoll do
+  it "should be tested" # probably inside of the integrations
+end

data/spec/lib/default_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe Firehose::Default do
   it "should have 7474 for default port" do
-    Firehose::Default::URI.to_s.should == '//127.0.0.1:7474'
+    Firehose::Default::URI.to_s.should == '//0.0.0.0:7474'
   end
-end
+end

data/spec/lib/publisher_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Firehose::Publisher do
+  include EM::TestHelper
+
+  let(:publisher)   { Firehose::Publisher.new }
+  let(:channel_key) { "/firehose/publisher/test/#{Time.now.to_i}" }
+  let(:message)     { "howdy friends!" }
+
+  it "should have 100 MAX_MESSAGES" do
+    Firehose::Publisher::MAX_MESSAGES.should == 100
+  end
+
+  it "should have 1 day TTL" do
+    Firehose::Publisher::TTL.should == 86400
+  end
+
+  describe "#publish" do
+    it "should publish message change" do
+      em do
+        hiredis = EM::Hiredis.connect
+        hiredis.subscribe "firehose:channel_updates"
+        hiredis.on(:message) {|_, msg|
+          msg.should == "#{channel_key}\n1\n#{message}"
+          em.next_tick { em.stop }
+        }
+        Firehose::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::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::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::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::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
+      em do
+        publisher.publish(channel_key, message).callback do
+          # Allow for 1 second of slippage/delay
+          redis_exec('TTL', "firehose:#{channel_key}:sequence").should > (Firehose::Publisher::TTL - 1)
+          redis_exec('TTL', "firehose:#{channel_key}:list").should > (Firehose::Publisher::TTL - 1)
+          em.stop
+        end
+      end
+    end
+  end
+end

data/spec/lib/rack/consumer_app_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe Firehose::Rack::ConsumerApp, :type => :request do
+  include Rack::Test::Methods
+  let(:app) { Firehose::Rack::ConsumerApp.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"
+end

data/spec/lib/rack/ping_app_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'rack/test'
+require 'async_rack_test'
+
+describe Firehose::Rack::PingApp, :type => :request do
+  include AsyncRackTest::Methods
+  let(:app) { Firehose::Rack::PingApp.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::PingApp::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_app_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'rack/test'
+require 'async_rack_test'
+
+describe Firehose::Rack::PublisherApp, :type => :request do
+  include AsyncRackTest::Methods
+  let(:app) { Firehose::Rack::PublisherApp.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
+  end
+end

data/spec/lib/subscriber_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Firehose::Subscriber do
+  include EM::TestHelper
+
+  let(:channel_key)     { '/bears/are/mean' }
+  let(:subscriber)      { Firehose::Subscriber.new(EM::Hiredis.connect) }
+  let(:dummy_subscriber){ Firehose::Subscriber.new(double('redis', :subscribe => EM::DefaultDeferrable.new, :on => nil)) }
+  let(:message)         { 'Raaaarrrrrr!!!!' }
+  let(:publisher)       { Firehose::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,17 +1,16 @@
+ENV['RACK_ENV'] ||= 'test'
+
 require 'logger'
 require 'em-http'
-require 'em-websocket-client'
+require 'faye/websocket'
+require 'hiredis'
 
-# Skip logging if VERBOSE isn't set to true.
 require 'firehose'
-Firehose.logger = Logger.new('/dev/null') unless ENV['VERBOSE']
 
-# Lets skip the verbosity of the thin for the test output.
-require 'thin'
-Thin::Logging.silent = true unless ENV['VERBOSE']
 
 # We use both EM::Http and Net::Http in this test lib. When EM:Http is fired up
-# we're usually hitting thins for integrations, and when Net::Http we want to mock that 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!
 
@@ -33,9 +32,51 @@ module EM::TestHelper
   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
-end
+  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