websocket-rails 0.1.5 → 0.1.6

data/spec/javascripts/websocket_rails/channel_spec.coffee

@@ -0,0 +1,51 @@
+describe 'WebSocketRails.Channel:', ->
+  beforeEach ->
+    @dispatcher =
+      new_message: -> true
+      dispatch: -> true
+      trigger_event: (event) -> true
+      state: 'connected'
+      connection_id: 12345
+    @channel = new WebSocketRails.Channel('public',@dispatcher)
+    sinon.spy @dispatcher, 'trigger_event'
+
+  afterEach ->
+    @dispatcher.trigger_event.restore()
+
+  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 '.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 '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).toBe true
+
+

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/websocket_connection_spec.coffee

@@ -0,0 +1,86 @@
+describe 'WebsocketRails.WebSocketConnection:', ->
+  beforeEach ->
+    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
+    @connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket',dispatcher)
+
+  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 set the onclose event on the WebSocket object to this.on_close', ->
+      expect(@connection._conn.onclose).toEqual @connection.on_close
+
+    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 '.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', ->
+      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.verify()
+
+  describe '.on_close', ->
+
+    it 'should dispatch the connection_closed event', ->
+      mock_dispatcher = sinon.mock @connection.dispatcher
+      mock_dispatcher.expects('dispatch').once()
+      @connection.on_close()
+      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,166 @@
+describe 'WebSocketRails:', ->
+  beforeEach ->
+    @url = 'localhost:3000/websocket'
+    WebSocketRails.WebSocketConnection = ->
+      connection_type: 'websocket'
+      flush_queue: -> true
+    WebSocketRails.HttpConnection = ->
+      connection_type: 'http'
+      flush_queue: -> true
+    @dispatcher = new WebSocketRails @url
+
+  describe 'constructor', ->
+
+    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_webosckets 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 '.new_message', ->
+
+    describe 'when this.state is "connecting"', ->
+      beforeEach ->
+        @message =
+          data:
+            connection_id: 123
+        @data = [['client_connected', @message]]
+
+      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.verify()
+
+      it 'should set the state to connected', ->
+        @dispatcher.new_message @data
+        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
+        mock_con.verify()
+
+      it 'should set the correct connection_id', ->
+        @dispatcher.new_message @data
+        expect(@dispatcher.connection_id).toEqual 123
+
+      it 'should call the user defined on_open callback', ->
+        spy = sinon.spy()
+        @dispatcher.on_open = spy
+        @dispatcher.new_message @data
+        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
+
+        it 'should run callbacks for result events', ->
+            data = [['event',@attributes]]
+            @event_mock.expects('run_callbacks').once()
+            @dispatcher.new_message data
+            @event_mock.verify()
+
+  describe '.bind', ->
+
+    it 'should store the callback on the correct event', ->
+      callback = ->
+      @dispatcher.bind 'event', callback
+      expect(@dispatcher.callbacks['event']).toContain callback
+
+  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.connection_id = 123
+      @dispatcher._conn =
+        trigger: ->
+        trigger_channel: ->
+
+    describe '.trigger', ->
+
+      it 'should delegate to the connection object', ->
+        con_trigger = sinon.spy @dispatcher._conn, 'trigger'
+        @dispatcher.trigger 'event', 'message'
+        event = new WebSocketRails.Event ['websocket_rails.subscribe', {channel: 'awesome'}, 123]
+        expect(con_trigger.called).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 '.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
+

data/spec/support/helper_methods.rb

@@ -15,7 +15,11 @@ module WebsocketRails
     end
 
     def encoded_message
-      ['test_event',{:user_name => 'Joe User'}].to_json
+      ['test_event',{:data => {:user_name => 'Joe User'}}].to_json
+    end
+
+    def subscribe_encoded_message
+      ['websocket_rails.subscribe',:data => nil, :channel => :awesome_channel].to_json
     end
 
     def received_encoded_message(connection_id)
@@ -30,4 +34,9 @@ module EM
   def self.next_tick(&block)
     block.call if block.respond_to?(:call)
   end
+  class PeriodicTimer
+    def initialize(interval)
+      @interval = interval
+    end
+  end
 end

data/spec/unit/channel_spec.rb

@@ -24,15 +24,14 @@ module WebsocketRails
     describe "#trigger" do
       it "should create a new event and trigger it on all subscribers" do
         event = double('event').as_null_object
-        Event.should_receive(:new) do |name,data,options|
+        Event.should_receive(:new) do |name,data|
           name.should == 'event'
-          data.should == 'data'
-          options.should be_a Hash
+          data[:data].should == 'data'
           event
         end
         connection.should_receive(:trigger).with(event)
         subject.subscribe connection
-        subject.trigger 'event', 'data'
+        subject.trigger 'event', :data => 'data'
       end
     end
 
@@ -42,5 +41,30 @@ module WebsocketRails
         subject.trigger_event 'event'
       end
     end
+
+    context "private channels" do
+      it "should be public by default" do
+        subject.instance_variable_get(:@private).should_not be_true
+      end
+
+      describe "#make_private" do
+        it "should set the @private instance variable to true" do
+          subject.make_private
+          subject.instance_variable_get(:@private).should be_true
+        end
+      end
+
+      describe "#is_private?" do
+        it "should return true if the channel is private" do
+          subject.instance_variable_set(:@private,true)
+          subject.is_private?.should be_true
+        end
+
+        it "should return false if the channel is public" do
+          subject.instance_variable_set(:@private,false)
+          subject.is_private?.should_not be_true
+        end
+      end
+    end
   end
 end

data/spec/unit/connection_adapters_spec.rb

@@ -97,7 +97,9 @@ module WebsocketRails
       end
 
       describe "#trigger" do
+=begin
         it "should add the event to the queue" do
+          pending
           subject.stub(:flush)
           subject.should_receive(:enqueue).with('event')
           subject.trigger 'event'
@@ -107,6 +109,21 @@ module WebsocketRails
           subject.should_receive(:flush)
           subject.trigger 'event'
         end
+=end
+      end
+
+      describe "#flush" do
+        before do
+          event = double('event')
+          event.stub!(:serialize).and_return("['event']")
+          3.times { subject.enqueue event }
+        end
+
+        it "should serialize all events into one array" do
+          serialized_array = "[['event'],['event'],['event']]"
+          subject.should_receive(:send).with(serialized_array)
+          subject.flush
+        end
       end
     end
   end

data/spec/unit/connection_manager_spec.rb

@@ -58,7 +58,7 @@ module WebsocketRails
         before(:each) { open_connection }
 
         it "should dispatch the appropriate event through the Dispatcher" do
-          mock_event = ["new_message","data"].to_json
+          mock_event = ["new_message",{:data =>"data"}].to_json
           dispatcher.should_receive(:dispatch) do |event|
             event.name.should == :new_message
             event.data.should == "data"

data/spec/unit/dispatcher_spec.rb

@@ -65,7 +65,7 @@ module WebsocketRails
 
       context "channel events" do
         it "should forward the data to the correct channel" do
-          event = Event.new 'test', 'data', :channel => :awesome_channel
+          event = Event.new 'test', :data => 'data', :channel => :awesome_channel
           channel = double('channel')
           channel.should_receive(:trigger_event).with(event)
           WebsocketRails.should_receive(:[]).with(:awesome_channel).and_return(channel)

data/spec/unit/event_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 module WebsocketRails
   describe Event do
-    let(:encoded_message) { '["new_message",{"message":"this is a message"}]' }
-    let(:encoded_message_string) { '["new_message","this is a message"]' }
-    let(:namespace_encoded_message_string) { '["product.new_message","this is a message"]' }
-    let(:namespace_encoded_message) { '["product.new_message",{"message":"this is a message"}]' }
-    let(:channel_encoded_message_string) { '["awesome_channel","new_message","this is a message"]' }
+    let(:encoded_message) { '["new_message",{"id":"1234","data":{"message":"this is a message"}}]' }
+    let(:encoded_message_string) { '["new_message",{"id":"1234","data":"this is a message"}]' }
+    let(:namespace_encoded_message_string) { '["product.new_message",{"id":"1234","data":"this is a message"}]' }
+    let(:namespace_encoded_message) { '["product.new_message",{"id":"1234","data":{"message":"this is a message"}}]' }
+    let(:channel_encoded_message_string) { '["new_message",{"id":"1234","channel":"awesome_channel","data":"this is a message","success":null,"result":null}]' }
     let(:connection) { double('connection') }
 
     before { connection.stub!(:id).and_return(1) }
@@ -68,13 +68,13 @@ module WebsocketRails
 
     context "new namespaced events" do
       it "should store the namespace in the namespace attribute" do
-        event = Event.new "event", {}, :connection => connection, :namespace => :product
+        event = Event.new "event", :data => {}, :connection => connection, :namespace => :product
         event.namespace.should == [:global,:product]
         event.name.should == :event
       end
 
       it "should store nested namespaces in the namespace attribute" do
-        event = Event.new "event", {}, :connection => connection, :namespace => [:product,:x_ray_vision]
+        event = Event.new "event", :data => {}, :connection => connection, :namespace => [:product,:x_ray_vision]
         event.namespace.should == [:global,:product,:x_ray_vision]
         event.name.should == :event
       end
@@ -82,7 +82,7 @@ module WebsocketRails
 
     context "new channel events" do
       it "should store the channel name in the channel attribute" do
-        event = Event.new "event", {}, :connection => connection, :channel => :awesome_channel
+        event = Event.new "event", :data => {}, :connection => connection, :channel => :awesome_channel
         event.channel.should == :awesome_channel
         event.name.should == :event
       end
@@ -90,7 +90,7 @@ module WebsocketRails
 
     describe "#is_channel?" do
       it "should return true if an event belongs to a channel" do
-        event = Event.new "event", "data", :channel => :awesome_channel
+        event = Event.new "event", :data => "data", :channel => :awesome_channel
         event.is_channel?.should be_true
       end
     end
@@ -99,14 +99,18 @@ module WebsocketRails
       context "messages in the global namespace" do
         it "should not add the global namespace to the event name" do
           event = Event.new_from_json encoded_message_string, connection
-          event.serialize.should == encoded_message_string
+          raw_data = event.serialize
+          data = JSON.parse raw_data
+          data[0].should == "new_message"
         end
       end
 
       context "messages in a child namespace" do
         it "should add the namespace to the front of the event name" do
           event = Event.new_from_json namespace_encoded_message_string, connection
-          event.serialize.should == namespace_encoded_message_string
+          raw_data = event.serialize
+          data = JSON.parse raw_data
+          data[0].should == "product.new_message"
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: websocket-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-04 00:00:00.000000000Z
+date: 2012-07-17 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -118,6 +118,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/assets/javascripts/websocket_rails/channel.js.coffee
+- lib/assets/javascripts/websocket_rails/event.js.coffee
 - lib/assets/javascripts/websocket_rails/http_connection.js.coffee
 - lib/assets/javascripts/websocket_rails/main.js
 - lib/assets/javascripts/websocket_rails/websocket_connection.js.coffee
@@ -139,6 +140,7 @@ files:
 - lib/websocket_rails/event_map.rb
 - lib/websocket_rails/event_queue.rb
 - lib/websocket_rails/internal_events.rb
+- lib/websocket_rails/logging.rb
 - lib/websocket_rails/version.rb
 - config/routes.rb
 - bin/thin-socketrails
@@ -180,6 +182,22 @@ files:
 - spec/dummy/Rakefile
 - spec/dummy/script/rails
 - spec/integration/connection_manager_spec.rb
+- spec/javascripts/generated/assets/channel.js
+- spec/javascripts/generated/assets/event.js
+- spec/javascripts/generated/assets/http_connection.js
+- spec/javascripts/generated/assets/websocket_connection.js
+- spec/javascripts/generated/assets/websocket_rails.js
+- spec/javascripts/generated/specs/channel_spec.js
+- spec/javascripts/generated/specs/event_spec.js
+- spec/javascripts/generated/specs/websocket_connection_spec.js
+- spec/javascripts/generated/specs/websocket_rails_spec.js
+- spec/javascripts/support/jasmine.yml
+- spec/javascripts/support/jasmine_config.rb
+- spec/javascripts/support/vendor/sinon-1.3.4.js
+- spec/javascripts/websocket_rails/channel_spec.coffee
+- spec/javascripts/websocket_rails/event_spec.coffee
+- spec/javascripts/websocket_rails/websocket_connection_spec.coffee
+- spec/javascripts/websocket_rails/websocket_rails_spec.coffee
 - spec/spec_helper.rb
 - spec/support/helper_methods.rb
 - spec/support/mock_web_socket.rb
@@ -213,7 +231,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3272086084276613534
+      hash: 3412477524173453969
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -222,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3272086084276613534
+      hash: 3412477524173453969
 requirements: []
 rubyforge_project: websocket-rails
 rubygems_version: 1.8.19