hkroger-websocket-rails 0.7.1

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