firehose 1.3.6 → 2.1.0

data/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "firehose",
-  "version": "1.3.3",
-  "main": "lib/assets/javascripts/firehose.js.coffee",
-  "devDependencies": {
-    "coffee-script": "*",
-    "jasmine-jquery": "git://github.com/velesin/jasmine-jquery.git",
-    "karma": "~0.12.16",
-    "karma-chrome-launcher": "~0.1.4",
-    "karma-coffee-preprocessor": "~0.2.1",
-    "karma-jasmine": "~0.2.0",
-    "karma-junit-reporter": "^0.2.2",
-    "karma-phantomjs-launcher": "^0.1.4",
-    "karma-safari-launcher": "*",
-    "karma-sprockets-mincer": "0.1.2"
-  }
-}

data/spec/integrations/integration_test_helper.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module IntegrationTestHelper
-  def start_server
-    @server_pid = fork do
-      Firehose::Server::App.new(:server => server, :port => uri.port).start
-    end
-
-    # Need to give the server a chance to boot up.
-    sleep 1
-  end
-
-  def stop_server
-    Process.kill 'INT', @server_pid
-  end
-
-
-  # Let isn't allowed in before(:all)
-  def uri
-    Firehose::URI
-  end
-end

data/spec/integrations/rainbows_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-require 'integrations/shared_examples'
-
-describe "rainbows" do
-  def server; :rainbows; end # Let isn't allowed in before(:all)
-  it_behaves_like 'Firehose::Rack::App'
-end

data/spec/integrations/shared_examples.rb

@@ -1,202 +0,0 @@
-require 'spec_helper'
-require 'integrations/integration_test_helper'
-require 'json'
-
-shared_examples_for 'Firehose::Rack::App' do
-  include EM::TestHelper
-  include IntegrationTestHelper
-
-  before(:all) do
-    Firehose::Client::Producer::Http.adapter = :em_http
-    start_server
-  end
-
-  after(:all) do
-    Firehose::Client::Producer::Http.adapter = nil
-    stop_server
-  end
-
-  before(:each) { WebMock.disable! }
-  after(:each)  { WebMock.enable! }
-
-  let(:app)       { Firehose::Rack::App.new }
-  let(:messages)  { (1..200).map{|n| "msg-#{n}" } }
-  let(:channel)   { "/firehose/integration/#{Time.now.to_i}" }
-  let(:http_url)  { "http://#{uri.host}:#{uri.port}#{channel}" }
-  let(:http_multi_url) { "http://#{uri.host}:#{uri.port}/channels@firehose" }
-  let(:ws_url)    { "ws://#{uri.host}:#{uri.port}#{channel}" }
-  let(:multiplex_channels) { ["/foo/bar", "/bar/baz", "/baz/quux"] }
-  let(:subscription_query) { multiplex_channels.map{|c| "#{c}!0"}.join(",") }
-
-  it "supports pub-sub http and websockets" do
-    # Setup variables that we'll use after we turn off EM to validate our
-    # test assertions.
-    outgoing, received = messages.dup, Hash.new{|h,k| h[k] = []}
-
-    # Our WS and Http clients call this when they have received their messages to determine
-    # when to turn off EM and make the test assertion at the very bottom.
-    succeed = Proc.new do
-      # TODO: For some weird reason the `add_timer` call causes up to 20 seconds of delay after
-      #       the test finishes running. However, without it the test will randomly fail with a
-      #       "Redis disconnected" error.
-      em.add_timer(1) { em.stop } if received.values.all?{|arr| arr.size == messages.size }
-    end
-
-    # Setup a publisher
-    publish = Proc.new do
-      Firehose::Client::Producer::Http.new.publish(outgoing.shift).to(channel, buffer_size: rand(100)) do
-        # The random timer ensures that sometimes the clients will be behind
-        # and sometimes they will be caught up.
-        EM::add_timer(rand*0.005) { publish.call } unless outgoing.empty?
-      end
-    end
-
-    # Lets have an HTTP Long poll client
-    http_long_poll = Proc.new do |cid, last_sequence|
-      http = EM::HttpRequest.new(http_url).get(:query => {'last_message_sequence' => last_sequence})
-      http.errback { em.stop }
-      http.callback do
-        frame = JSON.parse(http.response, :symbolize_names => true)
-        received[cid] << frame[:message]
-        if received[cid].size < messages.size
-          # Add some jitter so the clients aren't syncronized
-          EM::add_timer(rand*0.001) { http_long_poll.call cid, frame[:last_sequence] }
-        else
-          succeed.call cid
-        end
-      end
-    end
-
-    # And test a web socket client too, at the same time.
-    websocket = Proc.new do |cid|
-      ws = Faye::WebSocket::Client.new(ws_url)
-
-      ws.onopen = lambda do |event|
-        ws.send('{"message_sequence":0}')
-      end
-
-      ws.onmessage = lambda do |event|
-        frame = JSON.parse(event.data, :symbolize_names => true)
-        received[cid] << frame[:message]
-        succeed.call cid unless received[cid].size < messages.size
-      end
-
-      ws.onclose = lambda do |event|
-        ws = nil
-      end
-
-      ws.onerror = lambda do |event|
-        raise 'ws failed' + "\n" + event.inspect
-      end
-    end
-
-    # Great, we have all the pieces in order, lets run this thing in the reactor.
-    em 180 do
-      # Start the clients.
-      websocket.call(1)
-      websocket.call(2)
-      http_long_poll.call(3)
-      http_long_poll.call(4)
-
-      # Wait a sec to let our clients set up.
-      em.add_timer(1){ publish.call }
-    end
-
-    # When EM stops, these assertions will be made.
-    expect(received.size).to eql(4)
-    received.each_value do |arr|
-      expect(arr.size).to eql(messages.size)
-      expect(arr.sort).to eql(messages.sort)
-    end
-  end
-
-  it "supports channel multiplexing for http_long_poll and websockets" do
-    # Setup variables that we'll use after we turn off EM to validate our
-    # test assertions.
-    outgoing, received = messages.dup, Hash.new{|h,k| h[k] = []}
-
-    # Our WS and Http clients call this when they have received their messages to determine
-    # when to turn off EM and make the test assertion at the very bottom.
-    succeed = Proc.new do
-      # TODO: For some weird reason the `add_timer` call causes up to 20 seconds of delay after
-      #       the test finishes running. However, without it the test will randomly fail with a
-      #       "Redis disconnected" error.
-      em.add_timer(1) { em.stop } if received.values.all?{|arr| arr.size == messages.size }
-    end
-
-    # Lets have an HTTP Long poll client using channel multiplexing
-    multiplexed_http_long_poll = Proc.new do |cid, last_sequence|
-      http = EM::HttpRequest.new(http_multi_url).get(:query => {'subscribe' => subscription_query})
-
-      http.errback { em.stop }
-      http.callback do
-        frame = JSON.parse(http.response, :symbolize_names => true)
-        received[cid] << frame[:message]
-        if received[cid].size < messages.size
-          # Add some jitter so the clients aren't syncronized
-          EM::add_timer(rand*0.001) { multiplexed_http_long_poll.call cid, frame[:last_sequence] }
-        else
-          succeed.call cid
-        end
-      end
-    end
-
-    # Test multiplexed web socket client
-    outgoing = messages.dup
-    publish_multi = Proc.new do
-      msg = outgoing.shift
-      chan = multiplex_channels[rand(multiplex_channels.size)]
-      Firehose::Client::Producer::Http.new.publish(msg).to(chan) do
-        EM::add_timer(rand*0.005) { publish_multi.call } unless outgoing.empty?
-      end
-    end
-
-    multiplexed_websocket = Proc.new do |cid|
-      ws = Faye::WebSocket::Client.new("ws://#{uri.host}:#{uri.port}/channels@firehose?subscribe=#{subscription_query}")
-
-      ws.onmessage = lambda do |event|
-        frame = JSON.parse(event.data, :symbolize_names => true)
-        received[cid] << frame[:message]
-        succeed.call cid unless received[cid].size < messages.size
-      end
-
-      ws.onclose = lambda do |event|
-        ws = nil
-      end
-
-      ws.onerror = lambda do |event|
-        raise 'ws failed' + "\n" + event.inspect
-      end
-    end
-
-    em 180 do
-      # Start the clients.
-      multiplexed_http_long_poll.call(5)
-      multiplexed_http_long_poll.call(6)
-      multiplexed_websocket.call(7)
-      multiplexed_websocket.call(8)
-
-      # Wait a sec to let our clients set up.
-      em.add_timer(1){ publish_multi.call }
-    end
-
-    # When EM stops, these assertions will be made.
-    expect(received.size).to eql(4)
-    received.each_value do |arr|
-      expect(arr.size).to be <= messages.size
-      # expect(arr.sort).to eql(messages.sort)
-    end
-  end
-
-
-  it "returns 400 error for long-polling when using http long polling and sequence header is < 0" do
-    em 5 do
-      http = EM::HttpRequest.new(http_url).get(:query => {'last_message_sequence' => -1})
-      http.errback { |e| raise e.inspect }
-      http.callback do
-        expect(http.response_header.status).to eql(400)
-        em.stop
-      end
-    end
-  end
-end

data/spec/integrations/thin_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-require 'integrations/shared_examples'
-
-describe "thin" do
-  def server; :thin; end # Let isn't allowed in before(:all)
-  it_behaves_like 'Firehose::Rack::App'
-end

data/spec/javascripts/firehose/base_spec.coffee

@@ -1,2 +0,0 @@
-describe 'Firehose namespace', ->
-  it 'exists', -> expect( window.Firehose ).toEqual jasmine.any Object

data/spec/javascripts/firehose/consumer_spec.coffee

@@ -1,45 +0,0 @@
-describe 'Firehose.Consumer', ->
-  beforeEach ->
-    @klass    = Firehose.Consumer
-    @instance = new @klass uri: 'test_uri', okInterval: 9999 # Stop crazy ajax loops during tests
-
-
-  #= Specs ===
-
-  describe 'new instance', ->
-    describe '@config', ->
-      beforeEach -> @subj = @instance.config
-
-      for callback in ['message','error','connected','disconnected','failed']
-        it "has a .#{callback} function", ->
-          expect( @subj[callback] ).toEqual jasmine.any Function
-
-      it 'has a params object', ->
-        expect( @subj.params ).toEqual jasmine.any Object
-
-      it 'has a parse function', ->
-        expect( @subj.parse ).toEqual jasmine.any Function
-
-  describe '#connect', ->
-    it 'runs without error', -> @instance.connect()
-
-    describe 'after #connect called', ->
-      beforeEach -> @instance.connect()
-
-      it 'creates a @transport instance', ->
-        expect( @instance.transport ).toEqual jasmine.any Firehose.Transport
-
-  describe '#stop', ->
-    describe 'when .connect called earlier', ->
-      beforeEach ->
-        @instance.connect()
-        sinon.spy @instance.transport, 'stop'
-
-      it 'calls stop once on @transport', ->
-        @instance.stop()
-        expect( @instance.transport.stop.calledOnce ).toBe true
-
-      it 'stops the upgrade timeout', ->
-        @instance.stop()
-        expect( @instance.upgradeTimeout? ).toBe false
-

data/spec/javascripts/firehose/long_poll_spec.coffee

@@ -1,44 +0,0 @@
-describe 'Firehose.LongPoll', ->
-  beforeEach ->
-    @klass    = Firehose.LongPoll
-    @instance = new @klass()
-
-  afterEach -> @instance.stop()
-
-  #= Specs ===
-
-  it '.ieSupported returns a Boolean', ->
-    expect( typeof @klass.ieSupported() ).toBe 'boolean'
-
-  it '.supported returns a Boolean', ->
-    expect( typeof @klass.supported() ).toBe 'boolean'
-
-  describe '#stop', ->
-    beforeEach ->
-      @instance._lastRequest     = $.ajax()
-      @instance._lastPingRequest = $.ajax()
-
-    it 'aborts the last request', ->
-      sinon.spy @instance._lastRequest, 'abort'
-      Object.freeze @instance # Prevents the delete call from modifying the request object, so we can verify the call
-      @instance.stop()
-      expect( @instance._lastRequest.abort.called ).toBe true
-
-    it 'deletes reference to the last request', ->
-      @instance.stop()
-      expect( @instance._lastRequest? ).toBe false
-
-    it 'aborts the last ping request', ->
-      sinon.spy @instance._lastPingRequest, 'abort'
-      Object.freeze @instance # Prevents the delete call from modifying the request object, so we can verify the call
-      @instance.stop()
-      expect( @instance._lastPingRequest.abort.called ).toBe true
-
-    it 'deletes reference to the last ping request', ->
-      @instance.stop()
-      expect( @instance._lastPingRequest? ).toBe false
-
-  describe 'callbacks', ->
-    for callback in ['_request','_success','_ping','_error']
-      it "has a #{callback} callback function", ->
-        expect( @instance[callback] ).toEqual jasmine.any Function

data/spec/javascripts/firehose/multiplexed_consumer_spec.coffee

@@ -1,72 +0,0 @@
-describe 'Firehose.MultiplexedConsumer', ->
-
-  beforeEach ->
-    @receivedMessages = []
-
-    @instance = new Firehose.MultiplexedConsumer
-      uri: '/'
-      okInterval: 9999 # Stop crazy ajax loops during tests
-      channels:
-        "/foo":
-          last_sequence: 0
-          message: (msg) =>
-            @receivedMessages.push msg
-        "/bar":
-          last_sequence: 10
-          message: (msg) =>
-            @receivedMessages.push msg
-
-    @instance.connected = ->
-      true
-
-    @instance.transport =
-      subscribe: (chan, opts) ->
-        true
-      unsubscribe: (chan, opts) ->
-        true
-
-  #= Specs ===
-
-  describe 'new instance', ->
-    it "receives only messages from channels it is currently subscribed to", ->
-      for i in [1..5]
-        @instance.message({channel: "/foo", message: JSON.stringify { message: "msg-#{i}" } })
-      for i in [6..10]
-        @instance.message({channel: "/bar", message: JSON.stringify { message: "msg-#{i}" } })
-
-      @instance.unsubscribe("/foo")
-
-      for i in [11..15]
-        @instance.message({channel: "/foo", message: JSON.stringify { message: "msg-#{i}" } })
-      for i in [16..20]
-        @instance.message({channel: "/bar", message: JSON.stringify { message: "msg-#{i}" } })
-
-      expect(@receivedMessages).toEqual(
-        {message: "msg-#{i}"} for i in [1,2,3,4,5,6,7,8,9,10,16,17,18,19,20]
-      )
-
-  describe "dynamic subscription handling", ->
-    it "subscribes & unsubscribes to a channel dynamically", ->
-      messages = []
-
-      @instance.message({channel: "/dynamic", message: JSON.stringify { message: "hello 1" }})
-      @instance.message({channel: "/dynamic", message: JSON.stringify { message: "hello 2" }})
-
-      expect(messages).toEqual([])
-
-      @instance.subscribe "/dynamic",
-        message: (msg) ->
-          messages.push(msg)
-
-      @instance.message({channel: "/dynamic", message: JSON.stringify { message: "hello 3" }})
-      @instance.message({channel: "/dynamic", message: JSON.stringify { message: "hello 4" }})
-
-      @instance.unsubscribe "/dynamic"
-
-      @instance.message({channel: "/dynamic", message: JSON.stringify { message: "hello 5" }})
-      @instance.message({channel: "/dynamic", message: JSON.stringify { message: "hello 6" }})
-
-      expect(messages).toEqual([
-        {message: "hello 3"},
-        {message: "hello 4"},
-      ])

data/spec/javascripts/firehose/transport_spec.coffee

@@ -1,30 +0,0 @@
-describe 'Firehose.Transport', ->
-  beforeEach ->
-    @klass    = Firehose.Transport
-    @instance = new @klass()
-
-  it '.supported returns false', -> expect( @klass.supported() ).toBe false
-  it '.name throws error',       -> expect( -> @instance.name  ).toThrow()
-  it '.stop throws error',       -> expect( -> @instance.stop  ).toThrow()
-
-  describe 'constructor', ->
-    it 'returns an instance',     -> expect( @instance             ).toEqual jasmine.any @klass
-    it 'sets the @config object', -> expect( @instance.config      ).toEqual jasmine.any Object
-    it 'sets a retry delay',      -> expect( @instance._retryDelay ).toEqual jasmine.any Number
-
-  describe '#connect', ->
-    describe 'when given a 500 delay', ->
-      beforeEach ->
-        @clock = sinon.useFakeTimers()
-        sinon.stub @instance, '_request'
-        @instance.connect 500
-
-      afterEach -> @clock.restore()
-
-      it 'does not call _request before the given delay', ->
-        @clock.tick 499
-        expect( @instance._request.called ).toBe false
-
-      it 'calls _request after the given delay', ->
-        @clock.tick 600
-        expect( @instance._request.called ).toBe true

data/spec/javascripts/firehose/websocket_spec.coffee

@@ -1,27 +0,0 @@
-describe 'Firehose.WebSocket', ->
-  beforeEach ->
-    @klass    = Firehose.WebSocket
-    @instance = new @klass()
-
-  #= Specs ===
-
-  it '.name returns a string',         -> expect( @instance.name() ).toEqual jasmine.any String
-  it '.ieSupported returns a Boolean', -> expect( typeof @klass.ieSupported() ).toBe 'boolean'
-  it '.supported returns a Boolean',   -> expect( typeof @klass.supported()   ).toBe 'boolean'
-
-  describe 'callbacks', ->
-    for callback in ['_request','_success','_ping','_error']
-      it "has a #{callback} callback function", ->
-        expect( @instance[callback] ).toEqual jasmine.any Function
-
-  describe '#stop', ->
-    beforeEach ->
-      # call _request directly so we don't have to wait for the setTimeout
-      # call to call _request in the next event loop iteration
-      @instance.connect( uri: '//localhost/test' )._request()
-      sinon.spy @instance.socket, 'close'
-      Object.freeze @instance # stop _cleanUp method deleting the socket
-
-    it 'closes the socket', ->
-      @instance.stop()
-      expect( @instance.socket.close.called ).toBe true

data/spec/javascripts/helpers/spec_helper.js

@@ -1,31 +0,0 @@
-require( '/javascripts/vendor/json2.js'        );
-require( '/javascripts/vendor/sinon-1.7.3.js'  );
-require( '/javascripts/vendor/jquery-1.11.1.js');
-require( '/javascripts/firehose/base.js'       );
-require( '/javascripts/firehose/transport.js'  );
-require( '/javascripts/firehose/web_socket.js' );
-require( '/javascripts/firehose/long_poll.js'  );
-require( '/javascripts/firehose/consumer.js'   );
-
-//= Mock out jQuery / Zepto calls
-window.$ = {
-  ajax : function(){
-    return {
-      abort : function (){}
-    }
-  },
-
-  ajaxSettings : {
-    xhr : function(){
-      return {
-        withCredentials : true
-      }
-    }
-  },
-
-  param : function(){
-    return { fake: 'params' }
-  },
-
-  supported : { }
-};