wwl-websocket-rails 0.7.1

data/spec/unit/connection_manager_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+module WebsocketRails
+  describe ConnectionManager do
+    include Rack::Test::Methods
+
+    def app
+      @app ||= ConnectionManager.new
+    end
+
+    def open_connection
+      subject.call(env)
+    end
+
+    let(:connections) { subject.connections }
+    let(:dispatcher) { subject.dispatcher }
+
+    before(:each) do
+      ConnectionAdapters::Base.any_instance.stub(:send)
+      @mock_socket = ConnectionAdapters::Base.new(mock_request, dispatcher)
+      ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket)
+    end
+
+    describe "#initialize" do
+      it "should create an empty connections hash" do
+        subject.connections.should be_a Hash
+      end
+
+      it "should create a new dispatcher instance" do
+        subject.dispatcher.should be_a Dispatcher
+      end
+    end
+
+    context "new connections" do
+      it "should add one to the total connection count" do
+        expect { open_connection }.to change { connections.count }.by(1)
+      end
+
+      it "should store the new connection in the @connections Hash" do
+        open_connection
+        connections[@mock_socket.id].should == @mock_socket
+      end
+
+      it "should return an Async Rack response" do
+        open_connection.should == [ -1, {}, [] ]
+      end
+
+      before do
+        SecureRandom.stub(:hex).and_return(1, 2)
+      end
+
+      it "gives the new connection a unique ID" do
+        @mock_socket.should_receive(:id=).with(1)
+        open_connection
+        @mock_socket.should_receive(:id=).with(2)
+        open_connection
+      end
+
+      context "user connections" do
+        before do
+          @mock_socket.stub(:user_connection?).and_return true
+          @mock_socket.stub(:user_identifier).and_return "El Jefe"
+          open_connection
+        end
+
+        it "stores the connection in the UserManager" do
+          WebsocketRails.users["El Jefe"].connections.first.should == @mock_socket
+        end
+      end
+    end
+
+    context "new POST event" do
+      before(:each) do
+        @mock_http = ConnectionAdapters::Http.new(mock_request, dispatcher)
+        @mock_http.id = 'is_i_as_string'
+        app.connections[@mock_http.id] = @mock_http
+      end
+
+      it "should receive the new event for the correct connection" do
+        @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(mock_request, dispatcher))
+        4.times { open_connection }
+      end
+
+      context "when receiving a new event" do
+        before(:each) { open_connection }
+
+        it "should dispatch the appropriate event through the Dispatcher" do
+          mock_event = ["new_message",{:data =>"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.on_message(mock_event)
+        end
+      end
+
+      context "when closing" do
+        it "should remove the connection object from the @connections array" do
+          @mock_socket.on_close
+          connections.has_key?(@mock_socket.id).should be_false
+        end
+
+        it "should decrement the connection count by one" do
+          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|
+            event.name.should == :client_disconnected
+            event.connection.should == @mock_socket
+          end
+          @mock_socket.on_close
+        end
+
+        context "user connections" do
+          before do
+            @mock_socket.stub(:user_connection?).and_return true
+            @mock_socket.stub(:user_identifier).and_return "El Jefe"
+          end
+
+          it "deletes the connection from the UserManager" do
+            @mock_socket.on_close
+            WebsocketRails.users["El Jefe"].class.should == UserManager::MissingConnection
+          end
+        end
+      end
+
+    end
+
+    context "invalid connections" do
+      before(:each) do
+        ConnectionAdapters.stub(:establish_connection).and_raise(InvalidConnectionError)
+      end
+
+      it "should return a 400 bad request error code" do
+        open_connection.first.should == 400
+      end
+    end
+  end
+end

data/spec/unit/controller_factory_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+module WebsocketRails
+  describe ControllerFactory do
+
+    class TestController < BaseController
+      attr_reader :_dispatcher, :_event
+
+      def initialize_session
+        true
+      end
+    end
+
+    let(:dispatcher) { double('dispatcher') }
+    let(:connection) { double('connection') }
+    let(:event) { double('event') }
+
+    subject { ControllerFactory.new(dispatcher) }
+
+    before do
+      connection.stub(:id).and_return(1)
+      event.stub(:connection).and_return(connection)
+    end
+
+    it "stores a reference to the dispatcher" do
+      subject.dispatcher.should == dispatcher
+    end
+
+    it "maintains a hash of controller data stores" do
+      subject.controller_stores.should be_a Hash
+    end
+
+    describe "#new_for_event" do
+
+      context "when Rails is defined and env is set to development" do
+
+        it "creates and returns a controller instance of the InternalController" do
+          rails_env = double(:rails_env)
+          Rails.stub(:env).and_return rails_env
+          rails_env.stub(:development?).and_return true
+          controller = subject.new_for_event(event, InternalController, 'some_method')
+          controller.class.should == InternalController
+        end
+
+      end
+
+      it "creates and returns a new controller instance" do
+        controller = subject.new_for_event(event, TestController, 'some_method')
+        controller.class.should == TestController
+      end
+
+      it "initializes the controller with the correct data_store" do
+        store = double('data_store')
+        subject.controller_stores[TestController] = store
+        controller = subject.new_for_event(event, TestController, 'some_method')
+        controller.controller_store.should == store
+      end
+
+      it "initializes the controller with the correct event" do
+        controller = subject.new_for_event(event, TestController, 'some_method')
+        controller.event.should == event
+      end
+
+      it "initializes the controller with the correct dispatcher" do
+        controller = subject.new_for_event(event, TestController, 'some_method')
+        controller._dispatcher.should == dispatcher
+      end
+
+      it "calls #initialize_session on the controller only once" do
+        TestController.any_instance.should_receive(:initialize_session).once
+        3.times { subject.new_for_event(event, TestController, 'some_method') }
+      end
+    end
+
+  end
+end

data/spec/unit/data_store_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+module WebsocketRails
+  module DataStore
+    describe Base do
+      it "extends Hash" do
+        subject.should be_a Hash
+      end
+
+      it "allows indifferent access" do
+        subject['key'] = true
+        subject[:key].should == true
+      end
+
+      describe "#instances" do
+        before do
+          Base.clear_all_instances
+          @connection = double('connection')
+          @controller = double('controller')
+        end
+
+        it "keeps track of all instantiated instances" do
+          store_one = Base.new
+          store_two = Base.new
+
+          store_one.instances.count.should == 2
+          store_two.instances.count.should == 2
+        end
+
+        it "separates instances based on class name" do
+          2.times { Connection.new(@connection) }
+          4.times { Controller.new(@controller) }
+
+          Connection.new(@connection).instances.count.should == 3
+          Controller.new(@controller).instances.count.should == 5
+        end
+      end
+
+      describe "#destroy!" do
+        before do
+          Base.clear_all_instances
+          @store = Base.new
+          @other = Base.new
+        end
+
+        it "removes itself from the instances collection" do
+          @other.instances.count.should == 2
+          @store.destroy!
+          @other.instances.count.should == 1
+        end
+      end
+
+      describe "#collect_all" do
+        before do
+          Base.clear_all_instances
+          @store_one = Base.new
+          @store_two = Base.new
+
+          @store_one[:secret] = 'token_one'
+          @store_two[:secret] = 'token_two'
+        end
+
+        context "called without a block" do
+          it "returns an array of values for the specified key from all store instances" do
+            secrets = @store_one.collect_all(:secret)
+            secrets.should == ['token_one', 'token_two']
+          end
+        end
+
+        context "called with a block" do
+          it "yields each value to the block" do
+            @store_one.collect_all(:secret) do |item|
+              item.should be_in ['token_one', 'token_two']
+            end
+          end
+        end
+      end
+    end
+
+    describe Connection do
+      before do
+        @connection = double('connection')
+        @connection.stub(:client_id).and_return(1)
+      end
+
+      let(:subject) { DataStore::Connection.new(@connection) }
+
+      it "stores a reference to it's connection" do
+        subject.connection.should == @connection
+      end
+    end
+
+    describe Controller do
+      before do
+        @controller = double('controller')
+      end
+
+      let(:subject) { DataStore::Controller.new(@controller) }
+
+      it "stores a reference to it's controller" do
+        subject.controller.should == @controller
+      end
+    end
+  end
+
+end

data/spec/unit/dispatcher_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+require 'support/mock_web_socket'
+
+def rename_module_const(mod, old_name, new_name)
+  if mod.const_defined? old_name
+    mod.const_set(new_name, mod.const_get(old_name))
+    mod.send(:remove_const, old_name)
+  end
+end
+
+def swizzle_module_const(mod, name, temp_name, &block)
+  rename_module_const(mod, name, temp_name)
+  yield block
+  rename_module_const(mod, temp_name, name)
+end
+
+def set_temp_module_const(mod, name, value, &block)
+  mod.const_set(name, value)
+  yield block
+  mod.send(:remove_const, name)
+end
+
+module WebsocketRails
+
+  class EventTarget
+    attr_reader :_event, :_dispatcher, :test_method, :catch_all_method
+  end
+
+  describe Dispatcher do
+
+    let(:event) { double('Event').as_null_object }
+    let(:connection) { MockWebSocket.new }
+    let(:connection_manager) { double('connection_manager').as_null_object }
+    subject { Dispatcher.new(connection_manager) }
+
+    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
+      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 an event" do
+      before do
+        EventMap.any_instance.stub(:routes_for).with(any_args).and_yield(EventTarget, :test_method)
+        event.stub(:name).and_return(:test_method)
+        event.stub(:data).and_return(:some_message)
+        event.stub(:connection).and_return(connection)
+        event.stub(:is_channel?).and_return(false)
+        event.stub(:is_invalid?).and_return(false)
+        event.stub(:is_internal?).and_return(false)
+      end
+
+      it "should execute the correct method on the target class" do
+        EventTarget.any_instance.should_receive(:process_action).with(:test_method, event)
+        subject.dispatch(event)
+      end
+
+      context "channel events" do
+        before do
+          subject.stub(:filtered_channels).and_return({})
+        end
+        it "should forward the data to the correct channel" do
+          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)
+          subject.dispatch event
+        end
+      end
+
+      context "filtered channel events" do
+        before do
+          subject.stub(:filtered_channels).and_return({:awesome_channel => EventTarget})
+        end
+        it "should execute the correct method on the target class" do
+          event = Event.new 'test_method', :data => 'some data', :channel => :awesome_channel
+          EventTarget.any_instance.should_receive(:process_action).with(:test_method, event)
+          subject.dispatch(event)
+        end
+      end
+
+      context "filtered channel catch all events" do
+        before do
+          subject.stub(:filtered_channels).and_return({:awesome_channel => [EventTarget, :catch_all_method]})
+        end
+
+        it "should execute the correct method on the target class" do
+          event = Event.new 'test_method', :data => 'some data', :channel => :awesome_channel
+          EventTarget.any_instance.should_receive(:process_action).with(:test_method, event)
+          EventTarget.any_instance.should_receive(:process_action).with(:catch_all_method, event)
+          subject.dispatch(event)
+        end
+      end
+
+      context "invalid events" do
+        before do
+          event.stub(:is_invalid?).and_return(true)
+        end
+
+        it "should not dispatch the event" do
+          subject.should_not_receive(:route)
+          subject.dispatch(event)
+        end
+      end
+    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(:trigger).with(@event)
+        subject.send_message @event
+      end
+    end
+
+    describe "#broadcast_message" do
+      before do
+        connection_manager.stub(:connections).and_return({"connection_id" => connection})
+        @event = Event.new_from_json( encoded_message, connection )
+      end
+
+      it "should send a message to all connected clients" do
+        connection.should_receive(:trigger).with(@event)
+        subject.broadcast_message @event
+      end
+    end
+
+    describe 'record_invalid_defined?' do
+
+      it 'should return false when RecordInvalid is not defined' do
+        if Object.const_defined?('ActiveRecord')
+          swizzle_module_const(ActiveRecord, 'RecordInvalid','TempRecordInvalid') do
+            subject.send(:record_invalid_defined?).should be_false
+          end
+        else
+          set_temp_module_const(Object, 'ActiveRecord', Module.new) do
+            subject.send(:record_invalid_defined?).should be_false
+          end
+        end
+      end
+
+      it 'should return false when ActiveRecord is not defined' do
+        swizzle_module_const(Object, 'ActiveRecord', 'TempActiveRecord') do
+          subject.send(:record_invalid_defined?).should be_false
+        end
+      end
+
+      it 'should return true if ActiveRecord::RecordInvalid is defined' do
+        if Object.const_defined?('ActiveRecord')
+          if ActiveRecord.const_defined?('RecordInvalid')
+            subject.send(:record_invalid_defined?).should be_true
+          else
+            set_temp_module_const(ActiveRecord, 'RecordInvalid', Class.new) do
+              subject.send(:record_invalid_defined?).should be_true
+            end
+          end
+        else
+          set_temp_module_const(Object, 'ActiveRecord', Module.new) do
+            set_temp_module_const(ActiveRecord, 'RecordInvalid', Class.new) do
+              subject.send(:record_invalid_defined?).should be_true
+            end
+          end
+        end
+
+      end
+
+      context 'when ActiveRecord::RecordInvalid is not defined' do
+
+        it 'should check that exception can be converted to JSON' do
+          subject.should_receive(:record_invalid_defined?).and_return false
+          ex = double(:exception)
+          ex.should_receive(:respond_to?).with(:to_json).and_return true
+          exception_data = subject.send(:extract_exception_data, ex)
+          exception_data.should == ex
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/event_map_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+# this classes are outside the WebsocketRails namespace to better reflect the actual
+# situation in a normal usage
+
+class ProductController < WebsocketRails::BaseController
+  def update_product
+    true
+  end
+end
+
+# name is chosen so that we know camelize is working correctly
+class ComplexProductController < WebsocketRails::BaseController
+
+  def simplify_product
+    true
+  end
+
+end
+
+
+module WebsocketRails
+  describe EventMap do
+
+
+    def define_test_events
+      WebsocketRails.config.route_block = nil
+      WebsocketRails::EventMap.describe do
+        subscribe :client_connected, :to => ChatController, :with_method => :new_user
+
+        namespace :product do
+          subscribe :update, :to => ProductController, :with_method => :update_product
+        end
+
+        namespace :complex_product do
+          subscribe :simplify, 'complex_product#simplify'
+        end
+
+      end
+    end
+
+    let(:dispatcher) { double('dispatcher').as_null_object }
+    subject { EventMap.new(dispatcher) }
+    before { define_test_events }
+
+    context "EventMap.describe" do
+      it "should store the event route block in the global configuration" do
+        WebsocketRails.config.route_block.should be_present
+      end
+    end
+
+    context "Events in the global namespace" do
+
+      it "should store the event in the correct namespace" do
+        subject.namespace.actions[:client_connected].should be_present
+        subject.namespace.name.should == :global
+      end
+
+      it "should store the class constant and method name in the events hash" do
+        subject.namespace.actions[:client_connected].should == [[ChatController,:new_user]]
+      end
+
+    end
+
+    context "Events in a child namespace" do
+
+      before { @namespace = subject.namespace }
+
+      it "should store the event in the correct namespaces" do
+        @namespace.namespaces[:product].actions[:update].should be_present
+        @namespace.namespaces[:complex_product].actions[:simplify].should be_present
+      end
+
+    end
+
+    context "#routes_for" do
+      context "with events in the global namespace" do
+        it "should yield the controller class and action name for each route defined for an event" do
+          event = HelperMethods::MockEvent.new(:client_connected, [:global])
+
+          subject.routes_for(event) do |klass, method|
+            klass.should == ChatController
+            method.should == :new_user
+          end
+        end
+      end
+
+      context "with events in a child namespace" do
+        it "should yield the controller and action name for each route defined with a hash for an event" do
+          ProductController.any_instance.should_receive(:action_executed)
+          event = HelperMethods::MockEvent.new :update, [:global,:product]
+
+          subject.routes_for(event) do |klass, method|
+            controller = klass.new
+            controller.action_executed
+            controller.class.should == ProductController
+            method.should == :update_product
+          end
+
+        end
+
+        it "should yield the controller and action name for each route defined with a string for an event" do
+          ComplexProductController.any_instance.should_receive(:action_executed)
+          event = HelperMethods::MockEvent.new :simplify, [:global,:complex_product]
+
+          subject.routes_for(event) do |klass, method|
+            controller = klass.new
+            controller.action_executed
+            controller.class.should == ComplexProductController
+            method.should == :simplify
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/unit/event_queue_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module WebsocketRails
+  describe EventQueue do
+
+    describe "#initialize" do
+      it "should create an empty queue" do
+        subject.queue.should == []
+      end
+    end
+
+    describe "#<<" do
+      it "should add the item to the queue" do
+        subject << 'event'
+        subject.queue.should == ['event']
+      end
+    end
+
+    describe "#flush" do
+      before do
+        subject.queue << 'event'
+      end
+
+      it "should yield all items in the queue" do
+        subject.flush do |event|
+          event.should == 'event'
+        end
+      end
+
+      it "should empty the queue" do
+        subject.flush
+        subject.queue.should == []
+      end
+    end
+  end
+end