websocket-rails 0.6.2 → 0.7.0

data/spec/javascripts/websocket_rails/channel_spec.coffee

@@ -1,20 +1,64 @@
 describe 'WebSocketRails.Channel:', ->
   beforeEach ->
-    @dispatcher =
+    @dispatcher = new class WebSocketRailsStub
       new_message: -> true
       dispatch: -> true
       trigger_event: (event) -> true
       state: 'connected'
-      connection_id: 12345
-    @channel = new WebSocketRails.Channel('public',@dispatcher)
+      _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 '.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)
+      @channel = new WebSocketRails.Channel('forchan', @dispatcher, false)
       @event = @dispatcher.trigger_event.lastCall.args[0]
 
     it 'should trigger an event containing the channel name', ->
@@ -30,22 +74,32 @@ describe 'WebSocketRails.Channel:', ->
     it 'should be public', ->
       expect(@channel.is_private).toBeFalsy
 
-    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 '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)
+      @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).toBe true
+      expect(@channel.is_private).toBeTruthy
 
 

data/spec/javascripts/websocket_rails/event_spec.coffee

@@ -2,7 +2,7 @@ describe 'WebSocketRails.Event', ->
   
   describe 'standard events', ->
     beforeEach ->
-      @data = ['event',{data: { message: 'test'} },12345]
+      @data = ['event', {data: { message: 'test'} }, 12345]
       @event = new WebSocketRails.Event(@data)
 
     it 'should generate an ID', ->
@@ -51,19 +51,19 @@ describe 'WebSocketRails.Event', ->
         data
       failure_func = (data) ->
         data
-      @data = ['event',{data: { message: 'test'} },12345]
-      @event = new WebSocketRails.Event(@data,success_func,failure_func)
+      @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'
+        expect(@event.run_callbacks(true, 'success')).toEqual 'success'
 
       it 'should not run the failure callback', ->
-        expect(@event.run_callbacks(true,'success')).toBeUndefined
+        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'
+        expect(@event.run_callbacks(false, 'failure')).toEqual 'failure'
 
       it 'should not run the failure callback', ->
-        expect(@event.run_callbacks(false,'failure')).toBeUndefined
+        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

@@ -1,23 +1,34 @@
 describe 'WebsocketRails.WebSocketConnection:', ->
+  SAMPLE_EVENT_DATA = ['event','message']
+  SAMPLE_EVENT = 
+    data: JSON.stringify(SAMPLE_EVENT_DATA)
+
   beforeEach ->
-    dispatcher =
+    @dispatcher =
       new_message: -> true
       dispatch: -> true
       state: 'connected'
     # Have to stub the WebSocket object due to Firefox error during jasmine:ci
-    window.WebSocket = (url) ->
-      @url  = url
-      @send = -> true
-    @dispatcher = dispatcher
-    @connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', dispatcher)
+    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 set the onmessage event on the WebSocket object to this.on_message', ->
-      expect(@connection._conn.onmessage).toEqual @connection.on_message
+    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 set the onclose event on the WebSocket object to this.on_close', ->
-      expect(@connection._conn.onclose).toEqual @connection.on_close
+    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', ->
@@ -28,6 +39,11 @@ describe 'WebsocketRails.WebSocketConnection:', ->
       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', ->
@@ -51,14 +67,13 @@ describe 'WebsocketRails.WebSocketConnection:', ->
   describe '.on_message', ->
 
     it 'should decode the message and pass it to the dispatcher', ->
-      encoded_data = JSON.stringify ['event','message']
-      event =
-        data: encoded_data
       mock_dispatcher = sinon.mock @connection.dispatcher
-      mock_dispatcher.expects('new_message').once().withArgs JSON.parse encoded_data
-      @connection.on_message event
+      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']
@@ -100,6 +115,29 @@ describe 'WebsocketRails.WebSocketConnection:', ->
 
       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']

data/spec/javascripts/websocket_rails/websocket_rails_spec.coffee

@@ -1,15 +1,17 @@
 describe 'WebSocketRails:', ->
   beforeEach ->
     @url = 'localhost:3000/websocket'
-    WebSocketRails.WebSocketConnection = ->
+    WebSocketRails.WebSocketConnection = class WebSocketConnectionStub extends WebSocketRails.AbstractConnection
       connection_type: 'websocket'
-      flush_queue: -> true
-    WebSocketRails.HttpConnection = ->
+    WebSocketRails.HttpConnection = class HttpConnectionStub extends WebSocketRails.AbstractConnection
       connection_type: 'http'
-      flush_queue: -> true
     @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
@@ -22,7 +24,7 @@ describe 'WebSocketRails:', ->
         dispatcher = new WebSocketRails @url, true
         expect(dispatcher._conn.connection_type).toEqual 'websocket'
 
-    describe 'when use_webosckets is false', ->
+    describe 'when use_websockets is false', ->
       it 'should use the Http Connection', ->
         dispatcher = new WebSocketRails @url, false
         expect(dispatcher._conn.connection_type).toEqual 'http'
@@ -33,39 +35,110 @@ describe 'WebSocketRails:', ->
         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 ->
-        @message =
-          data:
-            connection_id: 123
-        @data = [['client_connected', @message]]
+        @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 @message.data
-        @dispatcher.new_message @data
+        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', ->
-        @dispatcher.new_message @data
+        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()
-        @dispatcher.new_message @data
+        helpers.startConnection(@dispatcher, @connection_id)
         mock_con.verify()
 
       it 'should set the correct connection_id', ->
-        @dispatcher.new_message @data
-        expect(@dispatcher.connection_id).toEqual 123
+        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
-        @dispatcher.new_message @data
+        helpers.startConnection(@dispatcher, @connection_id)
         expect(spy.calledOnce).toEqual true
 
     describe 'after the connection has been established', ->
@@ -96,12 +169,17 @@ describe 'WebSocketRails:', ->
           @event = { run_callbacks: (data) -> }
           @event_mock = sinon.mock @event
           @dispatcher.queue[1] = @event
+          @event_data = [['event',@attributes]]
 
         it 'should run callbacks for result events', ->
-            data = [['event',@attributes]]
-            @event_mock.expects('run_callbacks').once()
-            @dispatcher.new_message data
-            @event_mock.verify()
+          @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', ->
 
@@ -121,18 +199,23 @@ describe 'WebSocketRails:', ->
 
   describe 'triggering events with', ->
     beforeEach ->
-      @dispatcher.connection_id = 123
       @dispatcher._conn =
+        connection_id: 123
         trigger: ->
-        trigger_channel: ->
 
     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', ->
-        con_trigger = sinon.spy @dispatcher._conn, 'trigger'
+        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'
-        event = new WebSocketRails.Event ['websocket_rails.subscribe', {channel: 'awesome'}, 123]
-        expect(con_trigger.called).toEqual true
 
   describe '.connection_stale', ->
     describe 'when state is connected', ->