wwl-websocket-rails 0.7.1

data/spec/spec_helpers/matchers/route_matchers_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe 'Route Matchers' do
+
+  class RouteSpecProductController < WebsocketRails::BaseController
+
+    def update_product
+    end
+
+    def delete_product
+    end
+
+  end
+
+  class RouteSpecWarehouseController < WebsocketRails::BaseController
+
+    def remove_product
+    end
+
+  end
+
+  def define_route_test_events
+    WebsocketRails.config.route_block = nil
+    WebsocketRails::EventMap.describe do
+
+      namespace :product do
+        subscribe :update, :to => RouteSpecProductController, :with_method => :update_product
+        subscribe :delete, :to => RouteSpecProductController, :with_method => :delete_product
+        subscribe :delete, :to => RouteSpecWarehouseController, :with_method => :remove_product
+      end
+    end
+  end
+
+  before { define_route_test_events }
+
+  describe 'be_routed_to' do
+
+    it 'should return true when the event is routed only to the specified controller' do
+     create_event('product.update', nil).should be_routed_to 'route_spec_product#update_product'
+    end
+
+    it 'should return true when the event is routed also to the specified controller' do
+     create_event('product.delete', nil).should be_routed_to 'route_spec_product#delete_product'
+    end
+
+    it 'should return false when the event is not routed to the specified controller' do
+      create_event('product.update', nil).should_not be_routed_to 'route_spec_product#delete_product'
+    end
+
+    it 'should produce the correct failure message' do
+      event = create_event('route_spec_product.update', nil)
+      matcher = be_routed_to 'route_spec_product#delete_product'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_failure_message 'expected event update to be routed to target route_spec_product#delete_product'
+    end
+
+    it 'should produce the correct negative failure message' do
+      event = create_event('product.update', nil)
+      matcher = be_routed_to 'route_spec_product#update_product'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_negative_failure_message 'expected event update not to be routed to target route_spec_product#update_product'
+    end
+
+    it 'should produce the correct description' do
+      event = create_event('product.update', nil)
+      matcher = be_routed_to 'route_spec_product#update_product'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_description 'be routed to target route_spec_product#update_product'
+    end
+
+  end
+
+  describe 'be_routed_only_to' do
+
+    it 'should return true when the event is routed only to the specified controller' do
+     create_event('product.update', nil).should be_routed_only_to 'route_spec_product#update_product'
+    end
+
+    it 'should return false when the event is routed also to the specified controller' do
+     create_event('product.delete', nil).should_not be_routed_only_to 'route_spec_product#delete_product'
+    end
+
+    it 'should return false when the event is not routed to the specified controller' do
+      create_event('product.update', nil).should_not be_routed_only_to 'route_spec_product#delete_product'
+    end
+
+    it 'should produce the correct failure message' do
+      event = create_event('product.update', nil)
+      matcher = be_routed_only_to 'route_spec_product#delete_product'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_failure_message 'expected event update to be routed only to target route_spec_product#delete_product'
+    end
+
+    it 'should produce the correct negative failure message' do
+      event = create_event('product.update', nil)
+      matcher = be_routed_only_to 'route_spec_product#update_product'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_negative_failure_message 'expected event update not to be routed only to target route_spec_product#update_product'
+    end
+
+    it 'should produce the correct description' do
+      event = create_event('product.update', nil)
+      matcher = be_routed_only_to 'route_spec_product#update_product'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_description 'be routed only to target route_spec_product#update_product'
+    end
+
+  end
+end

data/spec/spec_helpers/matchers/trigger_matchers_spec.rb

@@ -0,0 +1,358 @@
+require 'spec_helper'
+
+describe 'Trigger Matchers' do
+
+  class TriggerSpecProductController < WebsocketRails::BaseController
+
+    # a method that does not trigger messages
+    def update_product
+    end
+
+    def delete_product
+      data = message[:data] ? 'Return Data' : nil
+      if message[:confirm_delete]
+        trigger_success(data)
+      else
+        trigger_failure(data)
+      end
+    end
+
+  end
+
+  def define_test_events
+    WebsocketRails.config.route_block = nil
+    WebsocketRails::EventMap.describe do
+
+      namespace :product do
+        subscribe :update, :to => TriggerSpecProductController, :with_method => :update_product
+        subscribe :delete, :to => TriggerSpecProductController, :with_method => :delete_product
+      end
+    end
+  end
+
+  before { define_test_events }
+
+  # as we have have 16 possible combinations of trigger messages and data matching pattern (data|no_data, success|failure,
+  # no_checking|checking_with_any|checking_with_nil|checking_with_exact_data) plus the case of no message at all
+  # for EACH of the matchers, resulting in a total 51 cases, we will not extensively test all cases for all matchers
+  # but we just make sure that coverage is 100%
+
+  describe 'trigger_message' do
+
+    it 'should trigger a success message with no data even when the event does not trigger any message with the default configuration' do
+      expect(create_event('product.update', nil).dispatch).to trigger_message
+    end
+
+    context 'When WebsocketRails.config.trigger_success_by_default = false' do
+      before {
+        WebsocketRails.config.stub(:trigger_success_by_default) { return false }
+      }   
+
+      it 'should trigger a message when the event does not trigger any message' do
+        expect(create_event('product.update', nil).dispatch).to trigger_message
+      end
+    end
+
+    it 'should return true when the message is a failure' do
+      expect(create_event('product.delete', {confirm_delete: false, data: true}).dispatch).to trigger_message
+    end
+
+    it 'should return true when the message is a success' do
+      expect(create_event('product.delete', {confirm_delete: true, data: false}).dispatch).to trigger_message
+    end
+
+    context 'when a message is triggered with no data' do
+
+      it 'should return true when no check is done' do
+        create_event('product.delete', {confirm_delete: true, data: false}).dispatch.should trigger_message
+      end
+
+      it 'should produce the correct negative failure message when no check on data is done' do
+        event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+        matcher = trigger_message
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger message'
+      end
+
+      it 'should return true when explicitly checking no data' do
+        create_event('product.delete', {confirm_delete: false, data: false}).dispatch.should trigger_message :nil
+      end
+
+      it 'should produce the correct negative failure message when explicitly checking no data' do
+        event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+        matcher = trigger_message :nil
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger message with no data'
+      end
+
+      it 'should return false when checking for some data' do
+        create_event('product.delete', {confirm_delete: true, data: false}).dispatch.should_not trigger_message :any
+      end
+
+      it 'should return the correct failure message when checking for some data' do
+        event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+        matcher = trigger_message :any
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.delete to trigger message with some data, instead it triggered a success message with no data'
+      end
+
+      it 'should return false when checking for specific data' do
+        create_event('product.delete', {confirm_delete: false, data: false}).dispatch.should_not trigger_message 'Expected Data'
+      end
+
+      it 'should return the correct failure message when checking for specific data' do
+        event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+        matcher = trigger_message 'Expected Data'
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.delete to trigger message with data Expected Data, instead it triggered a success message with no data'
+      end
+
+    end
+
+    context 'when a message is triggered with some data' do
+
+      it 'should return true when no check is done' do
+        create_event('product.delete', {confirm_delete: true, data: true}).dispatch.should trigger_message
+      end
+
+      it 'should return false when explicitly checking no data' do
+        create_event('product.delete', {confirm_delete: false, data: true}).dispatch.should_not trigger_message :nil
+      end
+
+      it 'should produce the correct failure message when explicitly checking for no data' do
+        event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+        matcher = trigger_message :nil
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.delete to trigger message with no data, instead it triggered a failure message with data Return Data'
+      end
+
+      it 'should return true when checking for some data' do
+        create_event('product.delete', {confirm_delete: true, data: true}).dispatch.should trigger_message :any
+      end
+
+      it 'should produce the correct negative failure message when checking for some data' do
+        event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+        matcher = trigger_message :any
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger message with some data'
+      end
+
+      it 'should return false when checking for specific data with wrong data' do
+        create_event('product.delete', {confirm_delete: false, data: true}).dispatch.should_not trigger_message 'Wrong Data'
+      end
+
+      it 'should produce the correct failure message when checking for specific data' do
+        event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+        matcher = trigger_message 'Wrong Data'
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.delete to trigger message with data Wrong Data, instead it triggered a failure message with data Return Data'
+      end
+
+      it 'should return true when checking for specific data with correct data' do
+        create_event('product.delete', {confirm_delete: true, data: true}).dispatch.should trigger_message 'Return Data'
+      end
+
+      it 'should produce the correct negative failure message when checking for specific data' do
+        event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+        matcher = trigger_message 'Return Data'
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger message with data Return Data'
+      end
+
+    end
+
+    it 'should produce the correct description' do
+      event = create_event('product.update', nil)
+      matcher = trigger_message 'Return Data'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_description 'trigger message with data Return Data'
+    end
+
+
+  end
+
+  describe 'trigger_success_message' do
+
+    context 'When WebsocketRails.config.trigger_success_by_default is true' do 
+
+      it 'should return true when the method does not trigger any message' do
+        expect(create_event('product.update', nil).dispatch).to trigger_success_message
+      end
+
+      it 'should produce the correct failure message when the method does not trigger any message' do
+        event = create_event('product.update', nil).dispatch
+        matcher = trigger_success_message 'Return Data'
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.update to trigger success message with data Return Data, instead it triggered a success message with no data'
+      end
+    end
+
+    context 'When WebsocketRails.config.trigger_success_by_default is false' do 
+      
+      before {
+        WebsocketRails.config.stub(:trigger_success_by_default) { false }
+      }   
+
+      it 'should return false when then method does not trigger any message' do
+        expect(create_event('product.update', nil).dispatch).not_to trigger_success_message
+      end
+
+      it 'should produce the correct failure message when the method does not trigger any message' do
+        event = create_event('product.update', nil).dispatch
+        matcher = trigger_success_message 'Return Data'
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.update to trigger success message with data Return Data, instead it triggered a no result message with no data'
+      end
+    end
+
+    it 'should return true when the method triggers a success message' do
+      create_event('product.delete', {confirm_delete: true, data: true}).dispatch.should trigger_success_message
+    end
+
+    it 'should produce the correct negative failure message when the method triggers a success message' do
+      event = create_event('product.delete', {confirm_delete: true, data: true}).dispatch
+      matcher = trigger_success_message :any
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger success message with some data'
+    end
+
+    it 'should return false when the method triggers a failure message' do
+      create_event('product.delete', {confirm_delete: false, data: true}).dispatch.should_not trigger_success_message
+    end
+
+    it 'should produce the correct failure message when the method triggers a failure message' do
+      event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+      matcher = trigger_success_message
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_failure_message 'expected product.delete to trigger success message, instead it triggered a failure message with data Return Data'
+    end
+
+  end
+
+  describe 'trigger_failure_message' do
+
+    it 'should return false when the method does not trigger any message' do
+      expect(create_event('product.update', nil).dispatch).not_to trigger_failure_message
+    end
+
+    it 'should produce the correct failure message when the method does not trigger any message' do
+      event = create_event('product.update', nil).dispatch
+      matcher = trigger_failure_message 'Return Data'
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_failure_message 'expected product.update to trigger failure message with data Return Data, instead it triggered a success message with no data'
+    end
+
+    context 'When WebsocketRails.config.trigger_success_by_default is false' do 
+      
+      before {
+        WebsocketRails.config.stub(:trigger_success_by_default) { false }
+      }      
+
+      it 'should produce the correct failure message when the method does not trigger any message' do
+        event = create_event('product.update', nil).dispatch
+        matcher = trigger_failure_message 'Return Data'
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_failure_message 'expected product.update to trigger failure message with data Return Data, instead it triggered a no result message with no data'
+      end
+
+    end
+
+    it 'should return false when the method triggers a success message' do
+      create_event('product.delete', {confirm_delete: true, data: true}).dispatch.should_not trigger_failure_message
+    end
+
+    it 'should produce the correct failure message when the method triggers a success message' do
+      event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+      matcher = trigger_failure_message :any
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_failure_message 'expected product.delete to trigger failure message with some data, instead it triggered a success message with no data'
+    end
+
+
+    it 'should return true when the method triggers a failure message' do
+      create_event('product.delete', {confirm_delete: false, data: true}).dispatch.should trigger_failure_message
+    end
+
+    it 'should produce the correct negative failure message when the method triggers a failure message' do
+      event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+      matcher = trigger_failure_message
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger failure message'
+    end
+
+  end
+
+  describe 'trigger_no_result_message' do 
+    
+    it 'should return false when the method does not trigger any message' do 
+      expect(create_event('product.update', nil).dispatch).not_to trigger_no_result_message
+    end
+
+    it 'should return false when the method triggers a success message' do 
+      expect(create_event('product.delete', {confirm_delete: true, data: false}).dispatch).not_to trigger_no_result_message
+    end
+
+    it 'should return false when the method triggers a failure message' do 
+      expect(create_event('product.delete', {confirm_delete: false, data: true}).dispatch).not_to trigger_no_result_message
+    end
+
+    it 'should produce the correct failure message when the method does not trigger any message' do 
+      event = create_event('product.update', nil).dispatch
+      matcher = trigger_no_result_message
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_failure_message 'expected product.update to trigger no result message (success == 2), instead it triggered a success message with no data'
+    end
+
+    it 'should produce the correct failure message when the method triggers a success message' do 
+      event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+      matcher = trigger_no_result_message
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger no result message (success == 2)'
+    end
+
+    it 'should produce the correct failure message when the method triggers a failure message' do 
+      event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+      matcher = trigger_no_result_message
+      cache_messages_for_matcher(matcher, event)
+      matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger no result message (success == 2)'
+    end
+
+    context 'When WebsocketRails.config.trigger_success_by_default is false' do
+      
+      before {
+        WebsocketRails.config.stub(:trigger_success_by_default) { false }
+      }
+      
+      it 'should return true when the method does not trigger any message' do 
+        puts WebsocketRails.config.trigger_success_by_default
+        puts WebsocketRails.config
+        expect(create_event('product.update', nil).dispatch).to trigger_no_result_message
+      end
+  
+      it 'should return false when the method triggers a success message' do 
+        expect(create_event('product.delete', {confirm_delete: true, data: false}).dispatch).not_to trigger_no_result_message
+      end
+
+      it 'should return false when the method triggers a failure message' do 
+        expect(create_event('product.delete', {confirm_delete: false, data: true}).dispatch).not_to trigger_no_result_message
+      end
+
+      it 'should produce the correct failure message when the method triggers a success message' do 
+        event = create_event('product.delete', {confirm_delete: true, data: false}).dispatch
+        matcher = trigger_no_result_message
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger no result message (success == 2)'
+      end
+
+      it 'should produce the correct failure message when the method triggers a failure message' do 
+        event = create_event('product.delete', {confirm_delete: false, data: true}).dispatch
+        matcher = trigger_no_result_message
+        cache_messages_for_matcher(matcher, event)
+        matcher.should produce_as_negative_failure_message 'expected product.delete not to trigger no result message (success == 2)'
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helpers/spec_helper_event_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module WebsocketRails
+
+  describe SpecHelperEvent do
+
+    before do
+      @dispatcher = double(:dispatcher)
+      Dispatcher.stub(:new).and_return @dispatcher
+      @event = SpecHelperEvent.new('my_event', data: 'my_data')
+    end
+
+    describe 'initialize' do
+
+      it 'should initialize the name and namespace of the event' do
+        @event.namespace.should == [:global]
+        @event.name.should == :my_event
+      end
+
+      it 'should initialize the data of the event' do
+        @event.data.should == 'my_data'
+      end
+
+      it 'should set the event to not triggered' do
+        @event.should_not be_triggered
+      end
+
+    end
+
+    describe 'trigger' do
+
+      it 'should set the triggered variable to true' do
+        @event.trigger
+        @event.should be_triggered
+      end
+
+    end
+
+    describe 'dispatch' do
+
+      it 'should invoke dispatch on the dispatcher object' do
+        @dispatcher.should_receive(:dispatch).with(@event)
+        @event.dispatch
+      end
+
+      it 'should return itself to be able to chain matchers' do
+        @dispatcher.stub(:dispatch)
+        @event.dispatch.should == @event
+      end
+
+    end
+
+  end
+
+end
+
+describe 'create_event' do
+
+  it 'should create a SpecHelperEvent with the correct parameters' do
+    event = create_event('my_event','my_data')
+    event.should be_a WebsocketRails::SpecHelperEvent
+    event.name.should == :my_event
+    event.data.should == 'my_data'
+  end
+
+end

data/spec/support/helper_methods.rb

@@ -0,0 +1,42 @@
+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 mock_request
+      @_request ||= ActionDispatch::Request.new(env)
+    end
+
+    def encoded_message
+      ['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)
+      [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
+  class PeriodicTimer
+    def initialize(interval)
+      @interval = interval
+    end
+  end
+end

data/spec/support/mock_web_socket.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module WebsocketRails
+  
+  class MockWebSocket
+    attr_writer :onmessage, :onerror, :onclose
+
+    def env
+      env = Rack::MockRequest.env_for('/websocket')
+    end
+    
+    def onmessage(event=nil)
+      @onmessage.call(event)
+    end
+    
+    def onerror(event=nil)
+      @onerror.call(event)
+    end
+    
+    def onclose(event=nil)
+      @onclose.call(event)
+    end
+    
+    def rack_response
+      [ -1, {}, [] ]
+    end
+    
+    def send(*args)
+      true
+    end
+
+    def trigger(event)
+      true
+    end
+
+    def id
+      object_id.to_i
+    end
+  end
+  
+end

data/spec/unit/base_controller_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+module WebsocketRails
+  describe BaseController do
+
+    class TestClass; end;
+
+    describe ".inherited" do
+      context "with Rails version 3" do
+        before do
+          Rails.stub(:version).and_return("3.2.13")
+        end
+
+        it "should call unloadable on the inherited class" do
+          Object.should_receive(:unloadable).with(TestClass)
+          BaseController.inherited(TestClass)
+        end
+      end
+
+      context "with Rails version 4" do
+        before do
+          Rails.stub(:version).and_return("4.0.0")
+        end
+
+        it "should call unloadable on the inherited class" do
+          Object.should_not_receive(:unloadable).with(TestClass)
+          BaseController.inherited(TestClass)
+        end
+      end
+    end
+
+    describe "before actions" do
+      class BeforeActionController < WebsocketRails::BaseController
+        before_action                             { self.before_array << :all }
+        before_action(:only => :only)             { self.before_array << :only_1 }
+        before_action(:only => :except)           { self.before_array << :only_2 }
+        before_action(:only => [:main, :only])    { self.before_array << :only_3 }
+        before_action(:only => [:except, :only])  { self.before_array << :only_4 }
+        before_action(:except => :except)         { self.before_array << :except_1 }
+        before_action(:except => :only)           { self.before_array << :except_2 }
+        before_action(:except => [:main, :except]){ self.before_array << :except_3 }
+        before_action(:except => [:only, :except]){ self.before_array << :except_4 }
+
+        attr_accessor :before_array
+
+        def initialize
+          @before_array = []
+        end
+        def main;end
+        def only;end
+        def except;end
+      end
+
+      let(:controller) { BeforeActionController.new }
+      it 'should handle before_action with no args' do
+        controller.instance_variable_set :@_action_name, 'main'
+        controller.process_action(:main, nil)
+        controller.before_array.should == [:all, :only_3, :except_1, :except_2, :except_4]
+      end
+
+      it 'should handle before_action with :only flag' do
+        controller.instance_variable_set :@_action_name, 'only'
+        controller.process_action(:only, nil)
+        controller.before_array.should == [:all, :only_1, :only_3, :only_4, :except_1, :except_3]
+      end
+
+      it 'should handle before_action with :except flag' do
+        controller.instance_variable_set :@_action_name, 'except'
+        controller.process_action(:except, nil)
+        controller.before_array.should == [:all, :only_2, :only_4, :except_2]
+      end
+    end
+  end
+end