wwl-websocket-rails 0.7.1

data/spec/unit/event_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+module WebsocketRails
+  describe Event do
+    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","user_id":null,"data":"this is a message","success":null,"result":null,"token":null,"server_token":"1234"}]' }
+    let(:synchronizable_encoded_message) { '["new_message",{"id":"1234","data":{"message":"this is a message"},"server_token":"1234"}]' }
+    let(:connection) { double('connection') }
+    let(:wrongly_encoded_message) { '["new_message",[{"id":"1234","data":{"message":"this is a message"}}]]' }
+
+    before { connection.stub(:id).and_return(1) }
+
+    describe ".new_from_json" do
+      context "messages in the global namespace" do
+        it "should decode a new message and store it" do
+          event = Event.new_from_json( encoded_message, connection )
+          event.connection.should == connection
+          event.name.should == :new_message
+          event.namespace.should == [:global]
+          event.data[:message].should == 'this is a message'
+        end
+      end
+
+      context "messages in a child namespace" do
+        it "should store the event with the correct namesapce" do
+          event = Event.new_from_json( namespace_encoded_message, connection )
+          event.namespace.should == [:global,:product]
+          event.name.should == :new_message
+          event.data[:message].should == 'this is a message'
+        end
+      end
+
+      context "invalid messages" do
+        it "should return an invalid event if data is wrongly encoded" do
+          event = Event.new_from_json( wrongly_encoded_message, connection )
+          event.is_invalid?.should be_true
+        end
+      end
+    end
+
+    describe ".new_on_open" do
+      before { @event = Event.new_on_open connection, {:message => 'connected'} }
+
+      it "should create an event named :client_connected" do
+        @event.name.should == :client_connected
+      end
+
+      it "should send the connection id to the client" do
+        @event.data[:connection_id].should == 1
+      end
+
+      it "should merge the optional data with the connection id" do
+        @event.data[:message].should == 'connected'
+      end
+    end
+
+    describe ".new_on_close" do
+      it "should create an event named :client_disconnected" do
+        event = Event.new_on_close( connection, "optional_data" )
+        event.name.should == :client_disconnected
+        event.data.should == "optional_data"
+        event.connection.should == connection
+      end
+    end
+
+    describe ".new_on_error" do
+      it "should create an event named :client_error" do
+        event = Event.new_on_error( connection, "optional_data" )
+        event.name.should == :client_error
+        event.data.should == "optional_data"
+        event.connection.should == connection
+      end
+    end
+
+    context "new namespaced events" do
+      it "should store the namespace in the namespace attribute" do
+        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", :data => {}, :connection => connection, :namespace => [:product,:x_ray_vision]
+        event.namespace.should == [:global,:product,:x_ray_vision]
+        event.name.should == :event
+      end
+    end
+
+    context "new channel events" do
+      it "should store the channel name in the channel attribute" do
+        event = Event.new "event", :data => {}, :connection => connection, :channel => :awesome_channel
+        event.channel.should == :awesome_channel
+        event.name.should == :event
+      end
+
+      it "should not raise an error if the channel name cannot be symbolized" do
+        expect { Event.new "event", :data => {}, :connection => connection, :channel => 5 }.to_not raise_error
+        event = Event.new "event", :data => {}, :connection => connection, :channel => 5
+        event.channel.should == :"5"
+      end
+    end
+
+    describe "#is_channel?" do
+      it "should return true if an event belongs to a channel" do
+        event = Event.new "event", :data => "data", :channel => :awesome_channel
+        event.is_channel?.should be_true
+      end
+    end
+
+    describe "#is_user?" do
+      it "returns true if the event is meant for a specific user" do
+        event = Event.new "event", :data => "data", :user_id => :username
+        event.is_user?
+      end
+    end
+
+    describe "#is_invalid?" do
+      it "returns true if the event name is :invalid_event" do
+        event = Event.new(:invalid_event)
+        event.is_invalid?.should be_true
+      end
+    end
+
+    describe "#is_internal?" do
+      it "returns true if the event is namespaced under websocket_rails" do
+        event = Event.new(:internal_event, :namespace => :websocket_rails)
+        event.is_internal?.should be_true
+      end
+    end
+
+    describe "#serialize" do
+      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
+          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
+          raw_data = event.serialize
+          data = JSON.parse raw_data
+          data[0].should == "product.new_message"
+        end
+      end
+
+      context "messages for a channel" do
+        it "should add the channel name as the first element of the serialized array" do
+          event = Event.new_from_json channel_encoded_message_string, connection
+          event.serialize.should == channel_encoded_message_string
+        end
+      end
+
+      context "messages for synchronization" do
+        it "should include the unique server token" do
+          event = Event.new_from_json synchronizable_encoded_message, connection
+          raw_data = event.serialize
+          data = JSON.parse raw_data
+          data[1]['server_token'].should == '1234'
+        end
+      end
+
+      describe "#as_json" do
+        it "returns a Hash representation of the Event" do
+          hash = { data: { 'test' => 'test'}, channel: :awesome_channel }
+          event = Event.new 'test', hash
+          event.as_json[0].should == :test
+          event.as_json[1][:data].should == hash[:data]
+          event.as_json[1][:channel].should == hash[:channel]
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/logging_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require "ostruct"
+
+module WebsocketRails
+  describe Logging do
+
+    class LoggedClass
+      include Logging
+    end
+
+    let(:io) { StringIO.new }
+    let(:object) { LoggedClass.new }
+
+    before do
+      WebsocketRails.config.logger = Logger.new(io)
+    end
+
+    describe "#info" do
+      it "logs the message" do
+        object.info "info logged"
+        io.string.should include("info logged")
+      end
+    end
+
+    describe "#debug" do
+      it "logs the message" do
+        object.debug "debug logged"
+        io.string.should include("debug logged")
+      end
+    end
+
+    describe "log_exception" do
+      let(:exception) { Exception.new('kaputt!').tap { |e| e.set_backtrace(['line 1', 'line 2']) } }
+
+      it "logs the exception message" do
+        object.log_exception(exception)
+        io.string.should include('kaputt!')
+      end
+
+      it "logs the backtrace" do
+        object.log_exception(exception)
+        io.string.should include("line 1")
+        io.string.should include("line 2")
+      end
+    end
+
+    context "logging an event" do
+      before do
+        data = {
+          namespace: :logger,
+          data: {message: "hello"},
+          connection: double('connection')
+        }
+        @event = Event.new(:logged_event, data)
+      end
+
+      describe "#log_event_start" do
+        it "logs the event information" do
+          object.log_event_start(@event)
+          io.string.should include("Started Event:")
+          io.string.should include("logger.logged_event")
+        end
+      end
+
+      describe "#log_event_end" do
+        it "logs the total time the event took to process" do
+          time = 12
+          object.log_event_end(@event, time)
+          io.string.should include("Event #{@event.encoded_name} Finished in #{time.to_f.to_d.to_s} seconds")
+        end
+      end
+
+      describe "#log_event" do
+        it "logs the start of the event" do
+          object.should_receive(:log_event_start).with(@event)
+          object.log_event(@event) { true }
+        end
+
+        it "logs the end of the event" do
+          time = Time.now
+          Time.stub(:now).and_return(time)
+          object.should_receive(:log_event_end).with(@event, 0)
+          object.log_event(@event) { true }
+        end
+
+        it "executes the block" do
+          executed = false
+          object.log_event(@event) { executed = true }
+          executed.should == true
+        end
+
+        it "logs any exceptions" do
+          exception = Exception.new("ouch")
+          object.should_receive(:log_exception).with(exception)
+          expect {
+            object.log_event(@event) { raise exception }
+          }.to raise_exception(exception.class, exception.message)
+        end
+      end
+    end
+
+    describe "#log_data?" do
+      before do
+        @hash_event = Event.new(:log_test, :data => {test: true})
+        @string_event = Event.new(:log_test, :data => "message")
+        @object_event = Event.new(:log_test, :data => OpenStruct.new)
+      end
+
+      it "returns true if data is an allowed type" do
+        object.log_data?(@hash_event).should == true
+        object.log_data?(@string_event).should == true
+      end
+
+      it "returns false if the data is not an allows type" do
+        object.log_data?(@object_event).should == false
+      end
+    end
+
+    describe "#log_event?" do
+      context "with an internal event" do
+        before do
+          @event = Event.new(:internal, :namespace => :websocket_rails)
+        end
+
+        context "when WebsocketRails.config.log_internal_events? is false" do
+          it "returns false" do
+            WebsocketRails.config.log_internal_events = false
+            object.log_event?(@event).should == false
+          end
+        end
+
+        context "when WebsocketRails.config.log_internal_events? is true" do
+          it "returns true" do
+            WebsocketRails.config.log_internal_events = true
+            object.log_event?(@event).should == true
+          end
+        end
+      end
+
+      context "with an external event" do
+        before do
+          @event = Event.new(:external)
+        end
+
+        context "when WebsocketRails.config.log_internal_events? is false" do
+          it "returns true" do
+            WebsocketRails.config.log_internal_events = false
+            object.log_event?(@event).should == true
+          end
+        end
+
+        context "when WebsocketRails.config.log_internal_events? is true" do
+          it "returns true" do
+            WebsocketRails.config.log_internal_events = true
+            object.log_event?(@event).should == true
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/synchronization_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+require "eventmachine"
+require "ostruct"
+
+module WebsocketRails
+  describe Synchronization do
+
+    around(:each) do |example|
+      EM.run do
+        Fiber.new do
+          @redis = Redis.new(WebsocketRails.config.redis_options)
+          @redis.del "websocket_rails.active_servers"
+          example.run
+        end.resume
+      end
+    end
+
+    after(:each) do
+      @redis.del "websocket_rails.active_servers"
+      EM.stop
+    end
+
+    let(:subject) { Synchronization.singleton }
+
+    describe "#publish" do
+      it "should add the serialized event to the websocket_rails.events channel" do
+        event = Event.new(:test_event, :channel => 'synchrony', :data => 'hello channel')
+        Redis.any_instance.should_receive(:publish).with("websocket_rails.events", event.serialize)
+
+        subject.publish(event)
+      end
+    end
+
+    describe "#synchronize!" do
+      # need to add an integration test to cover this.
+    end
+
+    describe "#trigger_incoming" do
+      context "when dispatching channel events" do
+        before do
+          @event = Event.new(:channel_event, :channel => :channel_one, :data => 'hello channel one')
+        end
+
+        it "triggers the event on the correct channel" do
+          WebsocketRails[:channel_one].should_receive(:trigger_event).with @event
+          subject.trigger_incoming @event
+        end
+      end
+
+      context "when dispatching user events" do
+        before do
+          @event = Event.new(:channel_event, :user_id => "username", :data => 'hello channel one')
+        end
+
+        context "and the user is not connected to this server" do
+          it "does nothing" do
+            subject.trigger_incoming(@event).should == nil
+          end
+        end
+
+        context "and the user is connected to this server" do
+          before do
+            @connection = double('Connection')
+            WebsocketRails.users["username"] = @connection
+          end
+
+          it "triggers the event on the correct user" do
+            WebsocketRails.users["username"].should_receive(:trigger).with @event
+            subject.trigger_incoming @event
+          end
+        end
+      end
+    end
+
+    describe "#generate_server_token" do
+      before do
+        SecureRandom.stub(:urlsafe_base64).and_return(1, 2, 3)
+      end
+
+      after do
+        @redis.del "websocket_rails.active_servers"
+      end
+
+      it "should generate a unique server token" do
+        SecureRandom.should_receive(:urlsafe_base64).at_least(1).times
+        subject.generate_server_token
+      end
+
+      it "should generate another id if the current id is already registered" do
+        @redis.sadd "websocket_rails.active_servers", 1
+        token = subject.generate_server_token
+        token.should == 2
+      end
+    end
+
+    describe "#register_server" do
+      it "should add the unique token to the active_servers key in redis" do
+        Redis.any_instance.should_receive(:sadd).with("websocket_rails.active_servers", "token")
+        subject.register_server "token"
+      end
+    end
+
+    describe "#remove_server" do
+      it "should remove the unique token from the active_servers key in redis" do
+        Redis.any_instance.should_receive(:srem).with("websocket_rails.active_servers", "token")
+        subject.remove_server "token"
+      end
+    end
+
+    describe "#register_user" do
+      before do
+        @connection = double('Connection')
+        @user = User.new
+        @user.attributes.update(name: 'Frank The Tank', email: 'frank@tank.com')
+        @user.instance_variable_set(:@new_record, false)
+        @user.instance_variable_set(:@destroyed, false)
+        @connection.stub(:user_identifier).and_return 'Frank The Tank'
+        @connection.stub(:user).and_return @user
+      end
+
+      it "stores the serialized user object in redis" do
+        @user.persisted?.should == true
+        Redis.any_instance.should_receive(:hset).with("websocket_rails.users", @connection.user_identifier, @user.as_json.to_json)
+        Synchronization.register_user(@connection)
+      end
+    end
+
+    describe "#destroy_user" do
+      it "stores the serialized user object in redis" do
+        Redis.any_instance.should_receive(:hdel).with("websocket_rails.users", 'user_id')
+        Synchronization.destroy_user('user_id')
+      end
+    end
+
+    describe "#find_user" do
+      it "retrieves the serialized user object in redis" do
+        Redis.any_instance.should_receive(:hget).with("websocket_rails.users", 'test')
+        Synchronization.find_user('test')
+      end
+    end
+
+    describe "#all_users" do
+      it "retrieves the entire serialized users hash redis" do
+        Redis.any_instance.should_receive(:hgetall).with("websocket_rails.users")
+        Synchronization.all_users
+      end
+    end
+
+  end
+end

data/spec/unit/target_validator_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+
+class ComplexProductController < WebsocketRails::BaseController
+
+  def simplify
+  end
+
+end
+
+module MyModule
+
+  class AnotherController < WebsocketRails::BaseController
+
+    def complicate
+    end
+
+  end
+
+  module MySubModule
+
+    class AThirdController < WebsocketRails::BaseController
+
+      def confuse
+      end
+
+    end
+
+  end
+
+end
+
+
+module WebsocketRails
+
+  describe TargetValidator do
+
+    describe 'validate_target' do
+
+      it 'should raise an error when target class is not supported' do
+        expect{TargetValidator.validate_target(50)}.to raise_error
+      end
+
+      it 'should raise if passed hash does not contain the to: key' do
+        expect{TargetValidator.validate_target(from: ComplexProductController, with_method: :simplify)}.to raise_error
+      end
+
+      it 'should raise if passed hash does not contain the with_method: key' do
+        expect{TargetValidator.validate_target(to: ComplexProductController, without_method: :simplify)}.to raise_error
+      end
+
+      it 'should raise if the string is not in the correct format' do
+        expect{TargetValidator.validate_target('malformed_string')}.to raise_error
+        expect{TargetValidator.validate_target('very#malformed#string')}.to raise_error
+      end
+
+      it 'should raise if the class specified in the String does not exist' do
+        expect{TargetValidator.validate_target('my_non_existent#my_method')}.to raise_error
+      end
+
+      it 'should parse correctly a well-formed Hash' do
+        TargetValidator::validate_target(to: ComplexProductController, with_method: :simplify).should == [ComplexProductController, :simplify]
+      end
+
+      context 'when the string is well-formed' do
+
+        it 'should parse correctly when the controller is a top-level' do
+          TargetValidator::validate_target('complex_product#simplify').should == [ComplexProductController, :simplify]
+        end
+
+        it 'should parse correctly when the controller belongs to a module' do
+          TargetValidator::validate_target('my_module/another#complicate').should == [MyModule::AnotherController, :complicate]
+        end
+
+        it 'should parse correctly with many levels of module nesting' do
+          TargetValidator::validate_target('my_module/my_sub_module/a_third#confuse').should == [MyModule::MySubModule::AThirdController, :confuse]
+        end
+
+      end
+
+    end
+
+
+  end
+
+
+
+end