websocket-rails 0.1.2 → 0.1.3

data/spec/integration/connection_manager_spec.rb

@@ -3,14 +3,24 @@ require 'support/mock_web_socket'
 
 module WebsocketRails
   describe ConnectionManager, "integration test" do
+
+    class ProductController < BaseController
+      def update_list; true; end
+    end
     
     def define_test_events
       WebsocketRails.route_block = nil
-      WebsocketRails::Events.describe_events do
+      WebsocketRails::EventMap.describe do
         subscribe :client_connected, to: ChatController, with_method: :new_user
         subscribe :change_username, to: ChatController, with_method: :change_username
         subscribe :client_error, to: ChatController, with_method: :error_occurred
         subscribe :client_disconnected, to: ChatController, with_method: :delete_user
+
+        subscribe :update_list, to: ChatController, with_method: :update_user_list
+
+        namespace :products do
+          subscribe :update_list, to: ProductController, with_method: :update_list
+        end
       end
     end
     
@@ -34,13 +44,22 @@ module WebsocketRails
           let(:test_message) { ['change_username',{user_name: 'Joe User'}] }
           let(:encoded_message) { test_message.to_json }
         
-          before(:each) { MockEvent = Struct.new(:data) }
-        
           it "should execute the controller action associated with the received event" do
-            mock_event = MockEvent.new( encoded_message )
             ChatController.any_instance.should_receive(:change_username)
             @server.call( env )
-            socket.onmessage( mock_event )
+            socket.on_message( encoded_message )
+          end
+        end
+
+        context "new message from client under a namespace" do
+          let(:test_message) { ['products.update_list',{product: 'x-ray-vision'}] }
+          let(:encoded_message) { test_message.to_json }
+          
+          it "should execute the controller action under the correct namespace" do
+            ChatController.any_instance.should_not_receive(:update_user_list)
+            ProductController.any_instance.should_receive(:update_list)
+            @server.call( env )
+            socket.on_message( encoded_message )
           end
         end
       
@@ -48,7 +67,7 @@ module WebsocketRails
           it "should execute the controller action associated with the 'client_error' event" do
             ChatController.any_instance.should_receive(:error_occurred)
             @server.call( env )
-            socket.onerror
+            socket.on_error
           end
         end
         
@@ -56,20 +75,18 @@ module WebsocketRails
           it "should execute the controller action associated with the 'client_disconnected' event" do
             ChatController.any_instance.should_receive(:delete_user)
             @server.call( env )
-            socket.onclose
+            socket.on_close
           end
         end
       end
     end
 
-    let(:env) { Rack::MockRequest.env_for('/websocket') }
-
     context "WebSocket Adapter" do
-      let(:socket) { MockWebSocket.new }
+      let(:socket) { @server.connections.first }
       
       before do
         ::Faye::WebSocket.stub(:websocket?).and_return(true)
-        ::Faye::WebSocket.stub(:new).and_return(socket)
+        ::Faye::WebSocket.stub(:new).and_return(MockWebSocket.new)
         @server = ConnectionManager.new
       end
 
@@ -77,10 +94,9 @@ module WebsocketRails
     end
 
     describe "HTTP Adapter" do
-      let(:socket) { ConnectionAdapters::Http.new( env ) }
+      let(:socket) { @server.connections.first }
 
       before do
-        ConnectionAdapters.stub(:establish_connection).and_return(socket)
         @server = ConnectionManager.new
       end
 

data/spec/spec_helper.rb

@@ -13,7 +13,7 @@ require 'websocket-rails'
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
-Dir["../../spec/support/**/*.rb"].each {|f| require f}
+Dir["./spec/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
   # == Mock Framework
@@ -25,7 +25,7 @@ RSpec.configure do |config|
   # config.mock_with :rr
   config.mock_with :rspec
   
-  #config.include FactoryGirl::Syntax::Methods
+  config.include WebsocketRails::HelperMethods
 
   # If true, the base class of anonymous controllers will be inferred
   # automatically. This will be the default behavior in future versions of
@@ -56,4 +56,4 @@ def enable_output
   $stdout = @orig_stdout
   @orig_stderr = nil
   @orig_stdout = nil
-end
+end

data/spec/support/helper_methods.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+module WebsocketRails
+  module HelperMethods
+    def env
+      @_env ||= begin
+        env = Rack::MockRequest.env_for('/websocket')
+        env['async.callback'] = Proc.new { |response| true }
+        env
+      end
+    end
+
+    def encoded_message
+      ['test_event',{user_name: 'Joe User'}].to_json
+    end
+
+    def received_encoded_message(connection_id)
+      [connection_id,'test_event',{user_name: 'Joe User'}].to_json
+    end
+
+    MockEvent = Struct.new(:name,:namespace)
+  end
+end
+
+module EM
+  def self.next_tick(&block)
+    block.call if block.respond_to?(:call)
+  end
+end

data/spec/support/mock_web_socket.rb

@@ -23,7 +23,11 @@ module WebsocketRails
     
     def send(*args)
       true
-    end    
+    end
+
+    def id
+      object_id.to_i
+    end
   end
   
-end
+end

data/spec/unit/connection_adapters/http_spec.rb

@@ -4,9 +4,7 @@ module WebsocketRails
   module ConnectionAdapters
     describe Http do
       
-      let(:env) { Rack::MockRequest.env_for('/websocket') }
-      
-      subject { Http.new( env ) }
+      subject { Http.new( env, double('Dispatcher').as_null_object ) }
       
       it "should be a subclass of ConnectionAdapters::Base" do
         subject.class.superclass.should == ConnectionAdapters::Base

data/spec/unit/connection_adapters/web_socket_spec.rb

@@ -8,17 +8,7 @@ module WebsocketRails
       before do
         @socket = MockWebSocket.new
         Faye::WebSocket.stub(:new).and_return(@socket)
-        @adapter = WebSocket.new( Hash.new )
-      end
-      
-      WebSocket::ADAPTER_EVENTS.each do |event|
-        it "should delegate ##{event} and ##{event}= to the Faye::WebSocket object" do
-          @socket.should_receive(event)
-          @socket.should_receive("#{event}=".to_sym)
-        
-          @adapter.__send__( "#{event}=".to_sym, Proc.new {|e| true } )
-          @adapter.__send__( event )
-        end
+        @adapter = WebSocket.new( env, double('Dispatcher').as_null_object )
       end
       
       context "#send" do

data/spec/unit/connection_adapters_spec.rb

@@ -10,47 +10,79 @@ module WebsocketRails
   
   describe ConnectionAdapters do
     
-    let(:env) { Rack::MockRequest.env_for('/websocket') }
-    
-    context ".register_adapter" do
+    context ".register" do
       it "should store a reference to the adapter in the adapters array" do
-        ConnectionAdapters.register_adapter( ConnectionAdapters::Test )
+        ConnectionAdapters.register( ConnectionAdapters::Test )
         ConnectionAdapters.adapters.include?( ConnectionAdapters::Test ).should be_true
       end
     end
     
     context ".establish_connection" do
       it "should return the correct connection adapter instance" do
-        adapter = ConnectionAdapters.establish_connection( env )
+        adapter = ConnectionAdapters.establish_connection( env, double('Dispatcher').as_null_object )
         adapter.class.should == ConnectionAdapters::Test
-      end      
+      end
     end
     
   end
     
   module ConnectionAdapters
     describe Base do
-      
-      let(:env) { Rack::MockRequest.env_for('/websocket') }
-      
-      subject { Base.new( env ) }
+      let(:dispatcher) { double('Dispatcher').as_null_object }
+      let(:event) { double('Event').as_null_object }
+      before  { Event.stub(:new_from_json).and_return(event) }
+      subject { Base.new( env, dispatcher ) }
       
       context "new adapters" do
         it "should register themselves in the adapters array when inherited" do
           adapter = Class.new( ConnectionAdapters::Base )
           ConnectionAdapters.adapters.include?( adapter ).should be_true
         end
-        
-        Base::ADAPTER_EVENTS.each do |event|
-          it "should define accessor methods for #{event}" do
-            proc = lambda { |event| true }
-            subject.__send__("#{event}=".to_sym,proc) 
-            subject.__send__(event).should == true
-          end
+      end
+
+      describe "#on_open" do
+        it "should dispatch an on_open event" do
+          on_open_event = double('event').as_null_object
+          subject.stub(:send)
+          Event.should_receive(:new_on_open).and_return(on_open_event)
+          dispatcher.should_receive(:dispatch).with(on_open_event)
+          subject.on_open
+        end
+      end
+
+      describe "#on_message" do
+        it "should forward the data to the dispatcher" do
+          dispatcher.should_receive(:dispatch).with(event)
+          subject.on_message encoded_message
+        end
+      end
+
+      describe "#on_close" do
+        it "should dispatch an on_close event" do
+          on_close_event = double('event')
+          Event.should_receive(:new_on_close).and_return(on_close_event)
+          dispatcher.should_receive(:dispatch).with(on_close_event)
+          subject.on_close("data")
+        end
+      end
+
+      describe "#on_error" do
+        it "should dispatch an on_error event" do
+          subject.stub(:on_close)
+          on_error_event = double('event').as_null_object
+          Event.should_receive(:new_on_error).and_return(on_error_event)
+          dispatcher.should_receive(:dispatch).with(on_error_event)
+          subject.on_error("data")
+        end
+
+        it "should fire the on_close event" do
+          data = "test_data"
+          subject.should_receive(:on_close).with(data)
+          subject.on_error("test_data")
         end
       end
       
-      context "#send" do
+      describe "#send" do
         it "should raise a NotImplementedError exception" do
           expect { subject.send :message }.to raise_exception( NotImplementedError )
         end
@@ -58,4 +90,4 @@ module WebsocketRails
       
     end
   end
-end
+end

data/spec/unit/connection_manager_spec.rb

@@ -13,13 +13,12 @@ module WebsocketRails
     end
     
     let(:connections) { subject.connections }
-    let(:env) { Rack::MockRequest.env_for('/websocket') }
+    let(:dispatcher) { subject.dispatcher }
     
     before(:each) do
-      @mock_socket = ConnectionAdapters::Base.new(env)
+      ConnectionAdapters::Base.any_instance.stub(:send)
+      @mock_socket = ConnectionAdapters::Base.new(env,dispatcher)
       ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket)
-      @dispatcher = double('dispatcher').as_null_object
-      Dispatcher.stub(:new).and_return(@dispatcher)
     end
     
     context "new connections" do
@@ -27,14 +26,6 @@ module WebsocketRails
         expect { open_connection }.to change { connections.count }.by(1)
       end
       
-      it "should execute the :client_connected event" do
-        @dispatcher.should_receive(:dispatch) do |event,data,connection|
-          event.should == 'client_connected'
-          connection.should == @mock_socket
-        end
-        open_connection
-      end
-      
       it "should store the new connection in the @connections array" do
         open_connection
         connections.include?(@mock_socket).should be_true
@@ -47,75 +38,60 @@ module WebsocketRails
 
     context "new POST event" do
       before(:each) do
-        @mock_http = ConnectionAdapters::Http.new(env)
+        @mock_http = ConnectionAdapters::Http.new(env,dispatcher)
         app.connections << @mock_http
       end
       
       it "should receive the new event for the correct connection" do
-        @dispatcher.should_receive(:receive).with('data',@mock_http)
-        post '/websocket', {:client_id => @mock_http.id, :data => 'data'}
+        @mock_http.should_receive(:on_message).with(encoded_message)
+        post '/websocket', {:client_id => @mock_http.id, :data => encoded_message}
       end
     end
     
     context "open connections" do
       before(:each) do
-        ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket,ConnectionAdapters::Base.new(env))
+        ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket,ConnectionAdapters::Base.new(env,dispatcher))
         4.times { open_connection }
       end
       
       context "when receiving a new event" do
-        before(:all) { MockEvent = Struct.new(:data) }
-        before(:each) { open_connection }      
+        before(:each) { open_connection }
 
         it "should dispatch the appropriate event through the Dispatcher" do
-          mock_event = MockEvent.new(:new_message)
-          @dispatcher.should_receive(:receive) do |event,connection|
-            event.should == :new_message
-            connection.should == @mock_socket
+          mock_event = ["new_message","data"].to_json
+          dispatcher.should_receive(:dispatch) do |event|
+            event.name.should == :new_message
+            event.data.should == "data"
+            event.connection.should == @mock_socket
           end
-          @mock_socket.onmessage(mock_event)
+          @mock_socket.on_message(mock_event)
         end
       end
       
-      context "when closing" do      
+      context "when closing" do
         it "should remove the connection object from the @connections array" do
-          @mock_socket.onclose
+          @mock_socket.on_close
           connections.include?(@mock_socket).should be_false
         end
       
         it "should decrement the connection count by one" do
-          expect { @mock_socket.onclose }.to change { connections.count }.by(-1)
+          expect { @mock_socket.on_close }.to change { connections.count }.by(-1)
         end
       
         it "should dispatch the :client_disconnected event" do
-          @dispatcher.should_receive(:dispatch) do |event,data,connection|
-            event.should == 'client_disconnected'
-            connection.should == @mock_socket
+          dispatcher.should_receive(:dispatch) do |event|
+            event.name.should == :client_disconnected
+            event.connection.should == @mock_socket
           end
-          @mock_socket.onclose
+          @mock_socket.on_close
         end
       end
     
-      context "when experiencing errors" do        
-        it "should dispatch the :client_error event" do
-          @mock_socket.stub(:onclose)
-          @dispatcher.should_receive(:dispatch) do |event,data,connection|
-            event.should == 'client_error'
-            connection.should == @mock_socket
-          end
-          @mock_socket.onerror
-        end
-        
-        it "should execute the #onclose procedure on connection" do
-          @mock_socket.should_receive(:onclose)
-          @mock_socket.onerror
-        end
-      end
     end
     
     context "invalid connections" do
       before(:each) do
-        ConnectionAdapters.stub(:establish_connection).and_return(false)
+        ConnectionAdapters.stub(:establish_connection).and_raise(InvalidConnectionError)
       end
       
       it "should return a 400 bad request error code" do

data/spec/unit/dispatcher_spec.rb

@@ -1,58 +1,89 @@
 require 'spec_helper'
 require 'support/mock_web_socket'
-require 'json'
 
 module WebsocketRails
   
   class EventTarget
-    attr_reader :_connection, :_message, :test_method
+    attr_reader :_event, :test_method
     
     def execute_observers(event_name)
       true
-    end    
+    end
   end
   
   describe Dispatcher do
     
+    let(:event) { double('Event') }
     let(:connection) { MockWebSocket.new }
     let(:connection_manager) { double('connection_manager').as_null_object }
     subject { Dispatcher.new(connection_manager) }
     
-    let(:test_message) { ['new_message',{message: 'this is a message'}] }
-    let(:encoded_message) { test_message.to_json }
-    
-    context "receiving a new message" do
-      it "should be decoded from JSON and dispatched" do
-        subject.stub(:dispatch) do |event,data,con|
-          event.should == 'new_message'
-          data['message'].should == 'this is a message'
-          con.should == connection
+    describe "#receive_encoded" do
+      context "receiving a new message" do
+        before do
+          Event.stub(:new_from_json).and_return( event )
+        end
+
+        it "should be decoded from JSON and dispatched" do
+          subject.stub(:dispatch) do |dispatch_event|
+            dispatch_event.should == event
+          end
+          subject.receive_encoded(encoded_message,connection)
         end
-        subject.receive(encoded_message,connection)
+      end
+    end
+
+    describe "#receive" do
+      before { Event.stub(:new).and_return( event ) }
+      it "should dispatch a new event" do
+        subject.stub(:dispatch) do |dispatch_event|
+          dispatch_event.should == event
+        end
+        subject.receive(:test_event,{},connection)
       end
     end
     
     context "dispatching a message for an event" do
-      before(:each) do
+      before do
         @target = EventTarget.new
-        Events.any_instance.stub(:routes_for).with(any_args).and_yield( @target, :test_method )
+        EventMap.any_instance.stub(:routes_for).with(any_args).and_yield( @target, :test_method )
+        event.stub(:name).and_return(:test_method)
+        event.stub(:data).and_return(:some_message)
+        event.stub(:connection).and_return(connection)
       end
       
       it "should execute the correct method on the target class" do
         @target.should_receive(:test_method)
-        subject.dispatch('test_method',{},connection)
+        subject.dispatch(event)
       end
       
-      it "should set the _message instance variable on the target object" do
-        subject.dispatch('test_method',:some_message,connection)
-        @target._message.should == :some_message
+      it "should set the _event instance variable on the target object" do
+        subject.dispatch(event)
+        @target._event.should == event
       end
-      
-      it "should set the _connection instance variable on the target object" do
-        subject.dispatch('test_method',:some_message,connection)
-        @target._connection.should == connection
+    end
+   
+    describe "#send_message" do
+      before do
+        @event = Event.new_from_json( encoded_message, connection )
+      end
+
+      it "should send a message to the event's connection object" do
+        connection.should_receive(:send).with(@event.serialize)
+        subject.send_message @event
+      end
+    end
+
+    describe "#broadcast_message" do
+      before do
+        connection_manager.stub(:connections).and_return([connection])
+        @event = Event.new_from_json( encoded_message, connection )
+      end
+
+      it "should send a message to all connected clients" do
+        connection.should_receive(:send).with(@event.serialize)
+        subject.broadcast_message @event
       end
     end
-    
   end
-end
+end