hkroger-websocket-rails 0.7.1

data/spec/javascripts/websocket_rails/channel_spec.coffee

@@ -0,0 +1,112 @@
+describe 'WebSocketRails.Channel:', ->
+  beforeEach ->
+    @dispatcher = new class WebSocketRailsStub
+      new_message: -> true
+      dispatch: -> true
+      trigger_event: (event) -> true
+      state: 'connected'
+      _conn:
+        connection_id: 12345
+    @channel = new WebSocketRails.Channel('public', @dispatcher)
+    sinon.spy @dispatcher, 'trigger_event'
+
+  afterEach ->
+    @dispatcher.trigger_event.restore()
+
+  describe '.bind', ->
+    it 'should add a function to the callbacks collection', ->
+      test_func = ->
+      @channel.bind 'event_name', test_func
+      expect(@channel._callbacks['event_name'].length).toBe 1
+      expect(@channel._callbacks['event_name']).toContain test_func
+
+  describe '.unbind', ->
+    it 'should remove the callbacks of an event', ->
+      callback = ->
+      @channel.bind 'event', callback
+      @channel.unbind 'event'
+      expect(@channel._callbacks['event']).toBeUndefined()
+
+  describe '.trigger', ->
+    describe 'before the channel token is set', ->
+      it 'queues the events', ->
+        @channel.trigger 'someEvent', 'someData'
+        queue = @channel._queue
+        expect(queue[0].name).toEqual 'someEvent'
+        expect(queue[0].data).toEqual 'someData'
+
+    describe 'when channel token is set', ->
+      it 'adds token to event metadata and dispatches event', ->
+        @channel._token = 'valid token'
+        @channel.trigger 'someEvent', 'someData'
+        expect(@dispatcher.trigger_event.calledWith(['someEvent',{token: 'valid token', data: 'someData'}]))
+
+  describe '.destroy', ->
+    it 'should destroy all callbacks', ->
+      event_callback = -> true
+      @channel.bind('new_message', @event_callback)
+
+      @channel.destroy()
+
+      expect(@channel._callbacks).toEqual {}
+
+    describe 'when this channel\'s connection is still active', ->
+      it 'should send unsubscribe event', ->
+        @channel.destroy()
+        expect(@dispatcher.trigger_event.args[0][0].name).toEqual 'websocket_rails.unsubscribe'
+
+    describe 'when this channel\'s connection is no more active', ->
+      beforeEach ->
+        @dispatcher._conn.connection_id++
+
+      it 'should not send unsubscribe event', ->
+        @channel.destroy()
+        expect(@dispatcher.trigger_event.notCalled).toEqual true
+
+  describe 'public channels', ->
+    beforeEach ->
+      @channel = new WebSocketRails.Channel('forchan', @dispatcher, false)
+      @event = @dispatcher.trigger_event.lastCall.args[0]
+
+    it 'should trigger an event containing the channel name', ->
+      expect(@event.data.channel).toEqual 'forchan'
+
+    it 'should trigger an event containing the correct connection_id', ->
+      expect(@event.connection_id).toEqual 12345
+
+    it 'should initialize an empty callbacks property', ->
+      expect(@channel._callbacks).toBeDefined()
+      expect(@channel._callbacks).toEqual {}
+
+    it 'should be public', ->
+      expect(@channel.is_private).toBeFalsy
+
+  describe 'channel tokens', ->
+    it 'should set token when event_name is websocket_rails.channel_token', ->
+      @channel.dispatch('websocket_rails.channel_token', {token: 'abc123'})
+      expect(@channel._token).toEqual 'abc123'
+
+    it "should refresh channel's connection_id after channel_token has been received", ->
+      # this is needed in case we would init the channel connection
+      # just before the connection has been established
+      @channel.connection_id = null
+      @channel.dispatch('websocket_rails.channel_token', {token: 'abc123'})
+      expect(@channel.connection_id).toEqual @dispatcher._conn.connection_id
+
+    it 'should flush the event queue after setting token', ->
+      @channel.trigger 'someEvent', 'someData'
+      @channel.dispatch('websocket_rails.channel_token', {token: 'abc123'})
+      expect(@channel._queue.length).toEqual(0)
+
+  describe 'private channels', ->
+    beforeEach ->
+      @channel = new WebSocketRails.Channel('forchan', @dispatcher, true)
+      @event = @dispatcher.trigger_event.lastCall.args[0]
+
+    it 'should trigger a subscribe_private event when created', ->
+      expect(@event.name).toEqual 'websocket_rails.subscribe_private'
+
+    it 'should be private', ->
+      expect(@channel.is_private).toBeTruthy
+
+

data/spec/javascripts/websocket_rails/event_spec.coffee

@@ -0,0 +1,69 @@
+describe 'WebSocketRails.Event', ->
+  
+  describe 'standard events', ->
+    beforeEach ->
+      @data = ['event', {data: { message: 'test'} }, 12345]
+      @event = new WebSocketRails.Event(@data)
+
+    it 'should generate an ID', ->
+      expect(@event.id).not.toBeNull
+
+    it 'should have a connection ID', ->
+      expect(@event.connection_id).toEqual 12345
+
+    it 'should assign the correct properties when passed a data array', ->
+      expect(@event.name).toEqual 'event'
+      expect(@event.data.message).toEqual 'test'
+
+    describe '.serialize()', ->
+      it 'should serialize the event as JSON', ->
+        @event.id = 1
+        serialized = "[\"event\",{\"id\":1,\"data\":{\"message\":\"test\"}}]"
+        expect(@event.serialize()).toEqual serialized
+
+    describe '.is_channel()', ->
+      it 'should be false', ->
+        expect(@event.is_channel()).toEqual false
+
+  describe 'channel events', ->
+    beforeEach ->
+      @data = ['event',{channel:'channel',data:{message: 'test'}}]
+      @event = new WebSocketRails.Event(@data)
+
+    it 'should assign the channel property', ->
+      expect(@event.channel).toEqual 'channel'
+      expect(@event.name).toEqual 'event'
+      expect(@event.data.message).toEqual 'test'
+
+    describe '.is_channel()', ->
+      it 'should be true', ->
+        expect(@event.is_channel()).toEqual true
+
+    describe '.serialize()', ->
+      it 'should serialize the event as JSON', ->
+        @event.id = 1
+        serialized = "[\"event\",{\"id\":1,\"channel\":\"channel\",\"data\":{\"message\":\"test\"}}]"
+        expect(@event.serialize()).toEqual serialized
+
+  describe '.run_callbacks()', ->
+    beforeEach ->
+      success_func = (data) ->
+        data
+      failure_func = (data) ->
+        data
+      @data = ['event', {data: { message: 'test'} }, 12345]
+      @event = new WebSocketRails.Event(@data, success_func, failure_func)
+
+    describe 'when successful', ->
+      it 'should run the success callback when passed true', ->
+        expect(@event.run_callbacks(true, 'success')).toEqual 'success'
+
+      it 'should not run the failure callback', ->
+        expect(@event.run_callbacks(true, 'success')).toBeUndefined
+
+    describe 'when failure', ->
+      it 'should run the failure callback when passed true', ->
+        expect(@event.run_callbacks(false, 'failure')).toEqual 'failure'
+
+      it 'should not run the failure callback', ->
+        expect(@event.run_callbacks(false, 'failure')).toBeUndefined

data/spec/javascripts/websocket_rails/helpers.coffee

@@ -0,0 +1,6 @@
+window.helpers = 
+  startConnection: (dispatcher, connection_id = 1) ->
+    message =
+      data:
+        connection_id: connection_id
+    dispatcher.new_message [['client_connected', message]]

data/spec/javascripts/websocket_rails/websocket_connection_spec.coffee

@@ -0,0 +1,158 @@
+describe 'WebsocketRails.WebSocketConnection:', ->
+  SAMPLE_EVENT_DATA = ['event','message']
+  SAMPLE_EVENT = 
+    data: JSON.stringify(SAMPLE_EVENT_DATA)
+
+  beforeEach ->
+    @dispatcher =
+      new_message: -> true
+      dispatch: -> true
+      state: 'connected'
+    # Have to stub the WebSocket object due to Firefox error during jasmine:ci
+    window.WebSocket = class WebSocketStub
+      constructor: (@url, @dispatcher) ->
+      send: -> true
+      close: -> @onclose(null)
+    @connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', @dispatcher)
+    @dispatcher._conn = @connection
+
+  describe 'constructor', ->
+
+    it 'should redirect onmessage events\' data from the WebSocket object to this.on_message', ->
+      mock_connection = sinon.mock @connection
+      mock_connection.expects('on_message').once().withArgs SAMPLE_EVENT_DATA
+      @connection._conn.onmessage(SAMPLE_EVENT)
+      mock_connection.verify()
+
+    it 'should redirect onclose events from the WebSocket object to this.on_close', ->
+      mock_connection = sinon.mock @connection
+      mock_connection.expects('on_close').once().withArgs SAMPLE_EVENT
+      @connection._conn.onclose(SAMPLE_EVENT)
+      mock_connection.verify()
+
+    describe 'with ssl', ->
+      it 'should not add the ws:// prefix to the URL', ->
+        connection = new WebSocketRails.WebSocketConnection('wss://localhost.com')
+        expect(connection.url).toEqual 'wss://localhost.com'
+
+    describe 'without ssl', ->
+      it 'should add the ws:// prefix to the URL', ->
+        expect(@connection.url).toEqual 'ws://localhost:3000/websocket'
+
+  describe '.close', ->
+    it 'should close the connection', ->
+      @connection.close()
+      expect(@dispatcher.state).toEqual 'disconnected'
+
+  describe '.trigger', ->
+
+    describe 'before the connection has been fully established', ->
+      it 'should queue up the events', ->
+        @connection.dispatcher.state = 'connecting'
+        event = new WebSocketRails.Event ['event','message']
+        mock_queue = sinon.mock @connection.message_queue
+        mock_queue.expects('push').once().withArgs event
+
+    describe 'after the connection has been fully established', ->
+      it 'should encode the data and send it through the WebSocket object', ->
+        @connection.dispatcher.state = 'connected'
+        event = new WebSocketRails.Event ['event','message']
+        @connection._conn =
+          send: -> true
+        mock_connection = sinon.mock @connection._conn
+        mock_connection.expects('send').once().withArgs event.serialize()
+        @connection.trigger event
+        mock_connection.verify()
+
+  describe '.on_message', ->
+
+    it 'should decode the message and pass it to the dispatcher', ->
+      mock_dispatcher = sinon.mock @connection.dispatcher
+      mock_dispatcher.expects('new_message').once().withArgs SAMPLE_EVENT_DATA
+      @connection.on_message SAMPLE_EVENT_DATA
+      mock_dispatcher.verify()
+
+
+
+  describe '.on_close', ->
+    it 'should dispatch the connection_closed event and pass the original event', ->
+      event = new WebSocketRails.Event ['event','message']
+      close_event = new WebSocketRails.Event(['connection_closed', event ])
+      sinon.spy @dispatcher, 'dispatch'
+      @connection.on_close close_event
+
+      dispatcher = @dispatcher.dispatch
+      lastCall = dispatcher.lastCall.args[0]
+      expect(dispatcher.calledOnce).toBe(true)
+      expect(lastCall.data).toEqual event.data
+
+      dispatcher.restore()
+
+    it 'sets the connection state on the dispatcher to disconnected', ->
+      close_event = new WebSocketRails.Event(['connection_closed', {} ])
+      @connection.on_close close_event
+
+      expect(@dispatcher.state).toEqual('disconnected')
+
+  describe '.on_error', ->
+    it 'should dispatch the connection_error event and pass the original event', ->
+
+      event = new WebSocketRails.Event ['event','message']
+      error_event = new WebSocketRails.Event(['connection_error', event ])
+      sinon.spy @dispatcher, 'dispatch'
+      @connection.on_error event
+
+      dispatcher = @dispatcher.dispatch
+      lastCall = dispatcher.lastCall.args[0]
+      expect(dispatcher.calledOnce).toBe(true)
+      expect(lastCall.data).toEqual event.data
+
+      dispatcher.restore()
+
+    it 'sets the connection state on the dispatcher to disconnected', ->
+      close_event = new WebSocketRails.Event(['connection_closed', {} ])
+      @connection.on_error close_event
+
+      expect(@dispatcher.state).toEqual('disconnected')
+
+  describe "it's no longer active connection", ->
+    beforeEach ->
+      @new_connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', @dispatcher)
+      @dispatcher._conn = @new_connection
+
+    it ".on_error should not react to the event response", ->
+      mock_dispatcher = sinon.mock @connection.dispatcher
+      mock_dispatcher.expects('dispatch').never()
+      @connection.on_error SAMPLE_EVENT_DATA
+      mock_dispatcher.verify()
+
+    it ".on_close should not react to the event response", ->
+      mock_dispatcher = sinon.mock @connection.dispatcher
+      mock_dispatcher.expects('dispatch').never()
+      @connection.on_close SAMPLE_EVENT_DATA
+      mock_dispatcher.verify()
+
+    it ".on_message should not react to the event response", ->
+      mock_dispatcher = sinon.mock @connection.dispatcher
+      mock_dispatcher.expects('new_message').never()
+      @connection.on_message SAMPLE_EVENT_DATA
+      mock_dispatcher.verify()
+
+  describe '.flush_queue', ->
+    beforeEach ->
+      @event = new WebSocketRails.Event ['event','message']
+      @connection.message_queue.push @event
+      @connection._conn =
+        send: -> true
+
+    it 'should send out all of the messages in the queue', ->
+      mock_connection = sinon.mock @connection._conn
+      mock_connection.expects('send').once().withArgs @event.serialize()
+      @connection.flush_queue()
+      mock_connection.verify()
+
+    it 'should empty the queue after sending', ->
+      expect( @connection.message_queue.length ).toEqual 1
+      @connection.flush_queue()
+      expect( @connection.message_queue.length ).toEqual 0
+

data/spec/javascripts/websocket_rails/websocket_rails_spec.coffee

@@ -0,0 +1,274 @@
+describe 'WebSocketRails:', ->
+  beforeEach ->
+    @url = 'localhost:3000/websocket'
+    WebSocketRails.WebSocketConnection = class WebSocketConnectionStub extends WebSocketRails.AbstractConnection
+      connection_type: 'websocket'
+    WebSocketRails.HttpConnection = class HttpConnectionStub extends WebSocketRails.AbstractConnection
+      connection_type: 'http'
+    @dispatcher = new WebSocketRails @url
+
+  describe 'constructor', ->
+    it 'should start connection automatically', ->
+      expect(@dispatcher.state).toEqual 'connecting'
+
+  describe '.connect', ->
+
+    it 'should set the new_message method on connection to this.new_message', ->
+      expect(@dispatcher._conn.new_message).toEqual @dispatcher.new_message
+
+    it 'should set the initial state to connecting', ->
+      expect(@dispatcher.state).toEqual 'connecting'
+
+    describe 'when use_websockets is true', ->
+      it 'should use the WebSocket Connection', ->
+        dispatcher = new WebSocketRails @url, true
+        expect(dispatcher._conn.connection_type).toEqual 'websocket'
+
+    describe 'when use_websockets is false', ->
+      it 'should use the Http Connection', ->
+        dispatcher = new WebSocketRails @url, false
+        expect(dispatcher._conn.connection_type).toEqual 'http'
+
+    describe 'when the browser does not support WebSockets', ->
+      it 'should use the Http Connection', ->
+        window.WebSocket = 'undefined'
+        dispatcher = new WebSocketRails @url, true
+        expect(dispatcher._conn.connection_type).toEqual 'http'
+
+  describe '.disconnect', ->
+    beforeEach ->
+      @dispatcher.disconnect()
+
+    it 'should close the connection', ->
+      expect(@dispatcher.state).toEqual 'disconnected'
+
+    it 'existing connection should be destroyed', ->
+      expect(@dispatcher._conn).toBeUndefined()
+
+  describe '.reconnect', ->
+    OLD_CONNECTION_ID = 1
+    NEW_CONNECTION_ID = 2
+
+    it 'should connect, when disconnected', ->
+      mock_dispatcher = sinon.mock @dispatcher
+      mock_dispatcher.expects('connect').once()
+      @dispatcher.disconnect()
+      @dispatcher.reconnect()
+      mock_dispatcher.verify()
+
+    it 'should recreate the connection', ->
+      helpers.startConnection(@dispatcher, OLD_CONNECTION_ID)
+      @dispatcher.reconnect()
+      helpers.startConnection(@dispatcher, NEW_CONNECTION_ID)
+
+      expect(@dispatcher._conn.connection_id).toEqual NEW_CONNECTION_ID
+
+    it 'should resend all uncompleted events', ->
+      event = @dispatcher.trigger('create_post')
+
+      helpers.startConnection(@dispatcher, OLD_CONNECTION_ID)
+      @dispatcher.reconnect()
+      helpers.startConnection(@dispatcher, NEW_CONNECTION_ID)
+
+      expect(@dispatcher.queue[event.id].connection_id).toEqual NEW_CONNECTION_ID
+
+    it 'should not resend completed events', ->
+      event = @dispatcher.trigger('create_post')
+      event.run_callbacks(true, {})
+
+      helpers.startConnection(@dispatcher, OLD_CONNECTION_ID)
+      @dispatcher.reconnect()
+      helpers.startConnection(@dispatcher, NEW_CONNECTION_ID)
+
+      expect(@dispatcher.queue[event.id].connection_id).toEqual OLD_CONNECTION_ID
+
+    it 'should reconnect to all channels', ->
+      mock_dispatcher = sinon.mock @dispatcher
+      mock_dispatcher.expects('reconnect_channels').once()
+      @dispatcher.reconnect()
+      mock_dispatcher.verify()
+
+  describe '.reconnect_channels', ->
+    beforeEach ->
+      @channel_callback = -> true
+      helpers.startConnection(@dispatcher, 1)
+      @dispatcher.subscribe('public 4chan')
+      @dispatcher.subscribe_private('private 4chan')
+      @dispatcher.channels['public 4chan'].bind('new_post', @channel_callback)
+
+    it 'should recreate existing channels, keeping their private/public type', ->
+      @dispatcher.reconnect_channels()
+      expect(@dispatcher.channels['public 4chan'].is_private).toEqual false
+      expect(@dispatcher.channels['private 4chan'].is_private).toEqual true
+
+    it 'should move all existing callbacks from old channel objects to new ones', ->
+      old_public_channel = @dispatcher.channels['public 4chan']
+
+      @dispatcher.reconnect_channels()
+
+      expect(old_public_channel._callbacks).toEqual {}
+      expect(@dispatcher.channels['public 4chan']._callbacks).toEqual {new_post: [@channel_callback]}
+
+  describe '.new_message', ->
+
+    describe 'when this.state is "connecting"', ->
+      beforeEach ->
+        @connection_id = 123
+
+      it 'should call this.connection_established on the "client_connected" event', ->
+        mock_dispatcher = sinon.mock @dispatcher
+        mock_dispatcher.expects('connection_established').once().withArgs(connection_id: @connection_id)
+        helpers.startConnection(@dispatcher, @connection_id)
+        mock_dispatcher.verify()
+
+      it 'should set the state to connected', ->
+        helpers.startConnection(@dispatcher, @connection_id)
+        expect(@dispatcher.state).toEqual 'connected'
+
+      it 'should flush any messages queued before the connection was established', ->
+        mock_con = sinon.mock @dispatcher._conn
+        mock_con.expects('flush_queue').once()
+        helpers.startConnection(@dispatcher, @connection_id)
+        mock_con.verify()
+
+      it 'should set the correct connection_id', ->
+        helpers.startConnection(@dispatcher, @connection_id)
+        expect(@dispatcher._conn.connection_id).toEqual 123
+
+      it 'should call the user defined on_open callback', ->
+        spy = sinon.spy()
+        @dispatcher.on_open = spy
+        helpers.startConnection(@dispatcher, @connection_id)
+        expect(spy.calledOnce).toEqual true
+
+    describe 'after the connection has been established', ->
+      beforeEach ->
+        @dispatcher.state = 'connected'
+        @attributes =
+          data: 'message'
+          channel: 'channel'
+
+      it 'should dispatch channel messages', ->
+        data = [['event',@attributes]]
+        mock_dispatcher = sinon.mock @dispatcher
+        mock_dispatcher.expects('dispatch_channel').once()
+        @dispatcher.new_message data
+        mock_dispatcher.verify()
+
+      it 'should dispatch standard events', ->
+        data = [['event','message']]
+        mock_dispatcher = sinon.mock @dispatcher
+        mock_dispatcher.expects('dispatch').once()
+        @dispatcher.new_message data
+        mock_dispatcher.verify()
+
+      describe 'result events', ->
+        beforeEach ->
+          @attributes['success'] = true
+          @attributes['id'] = 1
+          @event = { run_callbacks: (data) -> }
+          @event_mock = sinon.mock @event
+          @dispatcher.queue[1] = @event
+          @event_data = [['event',@attributes]]
+
+        it 'should run callbacks for result events', ->
+          @event_mock.expects('run_callbacks').once()
+          @dispatcher.new_message @event_data
+          @event_mock.verify()
+
+        it 'should remove the event from the queue', ->
+          @dispatcher.new_message @event_data
+          expect(@dispatcher.queue[1]).toBeUndefined()
+
+
+  describe '.bind', ->
+
+    it 'should store the callback on the correct event', ->
+      callback = ->
+      @dispatcher.bind 'event', callback
+      expect(@dispatcher.callbacks['event']).toContain callback
+
+  describe '.unbind', ->
+
+    it 'should delete the callback on the correct event', ->
+      callback = ->
+      @dispatcher.bind 'event', callback
+      @dispatcher.unbind 'event'
+      expect(@dispatcher.callbacks['event']).toBeUndefined()
+
+  describe '.dispatch', ->
+
+    it 'should execute the callback for the correct event', ->
+      callback = sinon.spy()
+      event = new WebSocketRails.Event(['event',{data: 'message'}])
+      @dispatcher.bind 'event', callback
+      @dispatcher.dispatch event
+      expect(callback.calledWith('message')).toEqual true
+
+  describe 'triggering events with', ->
+    beforeEach ->
+      @dispatcher._conn =
+        connection_id: 123
+        trigger: ->
+
+    describe '.trigger', ->
+      it 'should add the event to the queue', ->
+        event = @dispatcher.trigger 'event', 'message'
+        expect(@dispatcher.queue[event.id]).toEqual event
+
+      it 'should delegate to the connection object', ->
+        conn_trigger = sinon.spy @dispatcher._conn, 'trigger'
+        @dispatcher.trigger 'event', 'message'
+        expect(conn_trigger.called).toEqual true
+
+      it "should not delegate to the connection object, if it's not available", ->
+        @dispatcher._conn = null
+        @dispatcher.trigger 'event', 'message'
+
+  describe '.connection_stale', ->
+    describe 'when state is connected', ->
+      it 'should return false', ->
+        @dispatcher.state = 'connected'
+        expect(@dispatcher.connection_stale()).toEqual false
+
+    describe 'when state is disconnected', ->
+      it 'should return true', ->
+        @dispatcher.state = 'disconnected'
+        expect(@dispatcher.connection_stale()).toEqual true
+
+  describe 'working with channels', ->
+    beforeEach ->
+      WebSocketRails.Channel = (@name,@dispatcher,@is_private) ->
+
+    describe '.subscribe', ->
+      describe 'for new channels', ->
+        it 'should create and store a new Channel object', ->
+          channel = @dispatcher.subscribe 'test_channel'
+          expect(channel.name).toEqual 'test_channel'
+
+      describe 'for existing channels', ->
+        it 'should return the same Channel object', ->
+          channel = @dispatcher.subscribe 'test_channel'
+          expect(@dispatcher.subscribe('test_channel')).toEqual channel
+
+    describe '.subscribe_private', ->
+      it 'should create private channels', ->
+        private_channel = @dispatcher.subscribe_private 'private_something'
+        expect(private_channel.is_private).toBe true
+
+    describe '.unsubscribe', ->
+      describe 'for existing channels', ->
+        it 'should remove the Channel object', ->
+          @dispatcher.unsubscribe 'test_channel'
+          expect(@dispatcher.channels['test_channel']).toBeUndefined
+
+    describe '.dispatch_channel', ->
+
+      it 'should delegate to the Channel object', ->
+        channel = @dispatcher.subscribe 'test'
+        channel.dispatch = ->
+        spy = sinon.spy channel, 'dispatch'
+        event = new WebSocketRails.Event(['event',{channel: 'test', data: 'awesome'}])
+        @dispatcher.dispatch_channel event
+        expect(spy.calledWith('event', 'awesome')).toEqual true
+