wwl-websocket-rails 0.7.1

data/spec/unit/channel_manager_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module WebsocketRails
+
+  describe ".channel_manager" do
+    it "should load a new channel manager when first called" do
+      WebsocketRails.channel_manager.should be_a ChannelManager
+    end
+  end
+
+  describe ".[]" do
+    it "should delegate to channel manager" do
+      ChannelManager.any_instance.should_receive(:[]).with(:awesome_channel)
+      WebsocketRails[:awesome_channel]
+    end
+  end
+
+  describe ".channel_tokens" do
+    it "should delegate to channel manager" do
+      ChannelManager.any_instance.should_receive(:channel_tokens)
+      WebsocketRails.channel_tokens
+    end
+  end
+
+  describe ChannelManager do
+
+    describe "#channel_tokens" do
+      it "should return a Hash-like" do
+        subject.channel_tokens.respond_to? :[]
+        subject.channel_tokens.respond_to? :has_key?
+      end
+
+      it 'is used to store Channel\'s token' do
+        ChannelManager.any_instance.should_receive(:channel_tokens)
+          .at_least(:twice).and_call_original
+        token = Channel.new(:my_new_test_channel).token
+        WebsocketRails.channel_tokens[:my_new_test_channel].should == token
+      end
+    end
+
+    describe "#[]" do
+      context "accessing a channel" do
+        it "should create the channel if it does not exist" do
+          subject[:awesome_channel].class.should == Channel
+        end
+      end
+    end
+
+    describe "unsubscribe" do
+      it "should unsubscribe connection from all channels" do
+        subject[:awesome_channel].should_receive(:unsubscribe).with(:some_connection)
+        subject[:awesome_channel]
+        subject.unsubscribe(:some_connection)
+      end
+    end
+
+  end
+end

data/spec/unit/channel_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+module WebsocketRails
+  describe Channel do
+    subject { Channel.new :awesome_channel }
+
+    let(:connection) { double('connection') }
+
+    before do
+      connection.stub(:trigger)
+    end
+
+    it "should maintain a pool of subscribed connections" do
+      subject.subscribers.should == []
+    end
+
+    describe "#subscribe" do
+      before do
+        connection.stub(:user).and_return({})
+        WebsocketRails.config.stub(:broadcast_subscriber_events?).and_return(true)
+      end
+      it "should trigger an event when subscriber joins" do
+        subject.should_receive(:trigger).with("subscriber_join", connection.user)
+        subject.subscribe connection
+      end
+
+      it "should add the connection to the subscriber pool" do
+        subject.subscribe connection
+        subject.subscribers.include?(connection).should be_true
+      end
+    end
+
+    describe "#unsubscribe" do
+      before do
+        connection.stub(:user).and_return({})
+        WebsocketRails.config.stub(:broadcast_subscriber_events?).and_return(true)
+      end
+      it "should remove connection from subscriber pool" do
+        subject.subscribe connection
+        subject.unsubscribe connection
+        subject.subscribers.include?(connection).should be_false
+      end
+
+      it "should do nothing if connection is not subscribed to channel" do
+        subject.unsubscribe connection
+        subject.subscribers.include?(connection).should be_false
+      end
+
+      it "should trigger an event when subscriber parts" do
+        subject.subscribers << connection
+        subject.should_receive(:trigger).with('subscriber_part', connection.user)
+        subject.unsubscribe connection
+      end
+    end
+
+    describe "#trigger" do
+      it "should create a new event and trigger it on all subscribers" do
+        event = double('event').as_null_object
+        Event.should_receive(:new) do |name,options|
+          name.should == 'event'
+          options[:data].should == 'data'
+          event
+        end
+        connection.should_receive(:trigger).with(event)
+        subject.subscribers << connection
+        subject.trigger 'event', 'data'
+      end
+    end
+
+    describe "#trigger_event" do
+      it "should forward the event to subscribers if token matches" do
+        event = Event.new 'awesome_event', {:channel => 'awesome_channel', :token => subject.token}
+        subject.should_receive(:send_data).with(event)
+        subject.trigger_event event
+      end
+
+      it "should ignore the event if the token is invalid" do
+        event = Event.new 'invalid_event', {:channel => 'awesome_channel', :token => 'invalid_token'}
+        subject.should_not_receive(:send_data).with(event)
+        subject.trigger_event event
+      end
+
+      it "should not propagate if event.propagate is false" do
+        event = Event.new 'awesome_event', {:channel => 'awesome_channel', :token => subject.token, :propagate => false}
+        connection.should_not_receive(:trigger)
+        subject.subscribers << connection
+        subject.trigger_event event
+      end
+    end
+
+    describe "#filter_with" do
+      it "should add the controller to the filtered_channels hash" do
+        filter = double('BaseController')
+        subject.filter_with(filter)
+        subject.filtered_channels[subject.name].should eq(filter)
+      end
+
+      it "should allow setting the catch_all method" do
+        filter = double('BaseController')
+        subject.filter_with(filter, :some_method)
+        subject.filtered_channels[subject.name].should eq([filter, :some_method])
+      end
+    end
+
+    context "private channels" do
+      before do
+        subject.subscribers << connection
+      end
+
+      it "should be public by default" do
+        subject.instance_variable_get(:@private).should_not be_true
+      end
+
+      describe "#make_private" do
+        it "should set the @private instance variable to true" do
+          subject.make_private
+          subject.instance_variable_get(:@private).should be_true
+        end
+
+        context "when Configuration#keep_subscribers_when_private? is false" do
+          it "should clear any existing subscribers in the channel" do
+            subject.subscribers.count.should == 1
+            subject.make_private
+            subject.subscribers.count.should == 0
+          end
+        end
+
+        context "when Configuration#keep_subscribers_when_private? is true" do
+          before do
+            WebsocketRails.config.keep_subscribers_when_private = true
+          end
+
+          it "should leave the existing subscribers in the channel" do
+            subject.subscribers.count.should == 1
+            subject.make_private
+            subject.subscribers.count.should == 1
+          end
+        end
+      end
+
+      describe "#is_private?" do
+        it "should return true if the channel is private" do
+          subject.instance_variable_set(:@private,true)
+          subject.is_private?.should be_true
+        end
+
+        it "should return false if the channel is public" do
+          subject.instance_variable_set(:@private,false)
+          subject.is_private?.should_not be_true
+        end
+      end
+
+      describe "#token" do
+        it 'is long enough' do
+          subject.token.length.should > 10
+        end
+
+        it 'remains the same between two call' do
+          subject.token.should == subject.token
+        end
+
+        it 'is the same for two channels with the same name' do
+          subject.token.should == Channel.new(subject.name).token
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/connection_adapters/http_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module WebsocketRails
+  module ConnectionAdapters
+    describe Http do
+
+      subject {
+        mr = mock_request
+        mr.stub(:protocol).and_return('http://')
+        mr.stub(:raw_host_with_port).and_return('localhost:3000')
+        Http.new(mr , double('Dispatcher').as_null_object )
+      }
+
+      it "should be a subclass of ConnectionAdapters::Base" do
+        subject.class.superclass.should == ConnectionAdapters::Base
+      end
+
+      it "should set the Content-Length header to text/json" do
+        subject.headers['Content-Type'].should == "text/json"
+      end
+
+      it "should set the Transfer-Encoding header to chunked" do
+        subject.headers['Transfer-Encoding'].should == "chunked"
+      end
+
+      it "should not set the Access-Control-Allow-Origin header" do
+        subject.headers['Access-Control-Allow-Origin'].should be_blank
+      end
+
+      context "with IE CORS hack enabled" do
+        it "should set the Access-Control-Allow-Origin when passed an array as configuration" do
+          WebsocketRails.config.allowed_origins = ['http://localhost:3000']
+          subject.headers['Access-Control-Allow-Origin'].should == 'http://localhost:3000'
+        end
+
+        it "should set the Access-Control-Allow-Origin when passed a string as configuration" do
+          WebsocketRails.config.allowed_origins = 'http://localhost:3000'
+          subject.headers['Access-Control-Allow-Origin'].should == 'http://localhost:3000'
+        end
+      end
+
+      context "#encode_chunk" do
+        it "should properly encode strings" do
+          subject.__send__(:encode_chunk,"test").should == "4\r\ntest\r\n"
+        end
+      end
+      
+      context "adapter methods" do
+        before do
+          @body = double('DeferrableBody').as_null_object
+          Http::DeferrableBody.stub(:new).and_return(@body)
+        end
+
+        context "#define_deferrable_callbacks" do
+          it "should define a callback for :succeeded" do
+            @body.should_receive(:callback)
+            subject
+          end
+
+          it "should define a callback for :failed" do
+            @body.should_receive(:errback)
+            subject
+          end
+        end
+
+        context "#send" do
+          it "should encode the message before sending" do
+            subject.should_receive(:encode_chunk).with('test message')
+            subject.send 'test message'
+          end
+
+          it "should enqueue the message on DeferrableBody" do
+            encoded_message = subject.__send__(:encode_chunk,'test message')
+            @body.should_receive(:chunk).with(encoded_message)
+            subject.send 'test message'
+          end
+        end
+
+        describe "#close!" do
+          it "calls #close! on the DefferableBody instance" do
+            @body.should_receive(:close!)
+            subject.close!
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/connection_adapters/web_socket_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'support/mock_web_socket'
+
+module WebsocketRails
+  module ConnectionAdapters
+    describe WebSocket do
+
+      before do
+        @socket = MockWebSocket.new
+        Faye::WebSocket.stub(:new).and_return(@socket)
+        @adapter = WebSocket.new( mock_request, double('Dispatcher').as_null_object )
+      end
+
+      describe "#send" do
+        it "should send the message to the websocket connection" do
+          @socket.should_receive(:send).with(:message)
+          @adapter.send :message
+        end
+      end
+
+      describe "#close!" do
+        it "calls #close on the underlying WebSocket connection" do
+          @socket.should_receive(:close)
+          @adapter.close!
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/connection_adapters_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+module WebsocketRails
+
+  class ConnectionAdapters::Test < ConnectionAdapters::Base
+    def self.accepts?(env)
+      true
+    end
+  end
+
+  describe ConnectionAdapters do
+
+    context ".register" do
+      it "should store a reference to the adapter in the adapters array" do
+        ConnectionAdapters.register( ConnectionAdapters::Test )
+        ConnectionAdapters.adapters.include?( ConnectionAdapters::Test ).should be_true
+      end
+    end
+
+    context ".establish_connection" do
+      before do
+        connection_manager = double(ConnectionManager)
+        connection_manager.stub(:connections).and_return({})
+        @dispatcher = double(Dispatcher).as_null_object
+        @dispatcher.stub(:connection_manager).and_return(connection_manager)
+      end
+
+      it "should return the correct connection adapter instance" do
+        adapter = ConnectionAdapters.establish_connection(mock_request, @dispatcher)
+        adapter.class.should == ConnectionAdapters::Test
+      end
+
+    end
+
+    context "ping_timer" do
+      it "should set a ping_timer to the default 10 seconds value" do
+        adapter = ConnectionAdapters.establish_connection(mock_request, @dispatcher)
+        adapter.instance_variable_get(:@ping_timer).interval.should == 10
+      end
+
+      it "should change the ping interval after creation" do
+        adapter = ConnectionAdapters.establish_connection(mock_request, @dispatcher)
+        adapter.instance_variable_get(:@ping_timer).interval.should == 10
+
+        adapter.ping_interval = 50
+        adapter.instance_variable_get(:@ping_timer).interval.should == 50
+      end
+
+      it "should not set a ping_timer if ping_interval < 1" do
+        WebsocketRails.config.default_ping_interval = 0
+        adapter = ConnectionAdapters.establish_connection(mock_request, @dispatcher)
+        adapter.instance_variable_get(:@ping_timer).should == nil
+      end
+
+      it "should set the ping_timer to the value in the config" do
+        WebsocketRails.config.default_ping_interval = 45
+        adapter = ConnectionAdapters.establish_connection(mock_request, @dispatcher)
+        adapter.instance_variable_get(:@ping_timer).interval.should == 45
+      end
+    end
+
+  end
+
+  module ConnectionAdapters
+    describe Base do
+      let(:connection_manager) { double(ConnectionManager).as_null_object }
+      let(:dispatcher) { double(Dispatcher).as_null_object }
+      let(:channel_manager) { double(ChannelManager).as_null_object }
+      let(:event) { double(Event).as_null_object }
+
+      before do
+        connection_manager.stub(:connections).and_return({})
+        dispatcher.stub(:connection_manager).and_return(connection_manager)
+        Event.stub(:new_from_json).and_return(event)
+      end
+
+      subject { Base.new(mock_request, dispatcher) }
+
+      context "new adapter" do
+        it "should register itself in the adapters array when inherited" do
+          adapter = Class.new( ConnectionAdapters::Base )
+          ConnectionAdapters.adapters.include?( adapter ).should be_true
+        end
+
+        it "should create a new DataStore::Connection instance" do
+          subject.data_store.should be_a DataStore::Connection
+        end
+
+        #before do
+        #  WebsocketRails.config.stub(:user_identifier).and_return(:name)
+        #  WebsocketRails::DelegationController.any_instance
+        #    .stub_chain(:current_user, :name)
+        #    .and_return('Frank')
+        #  subject
+        #end
+
+        #it "adds itself to the UserManager Hash" do
+        #  WebsocketRails.users['Frank'].should == subject
+        #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
+
+      describe "#send_message" do
+        before do
+          Event.any_instance.stub(:trigger)
+        end
+        after do
+          subject.send_message :message, "some_data"
+        end
+
+        it "creates and triggers a new event" do
+          Event.any_instance.should_receive(:trigger)
+        end
+
+        it "sets it's user identifier on the event" do
+          subject.stub(:user_identifier).and_return(:some_name_or_id)
+          Event.should_receive(:new) do |name, options|
+            options[:user_id].should == :some_name_or_id
+          end.and_call_original
+        end
+
+        it "sets the connection property of the event correctly" do
+          subject.stub(:user_identifier).and_return(:some_name_or_id)
+          Event.should_receive(:new) do |name, options|
+            options[:connection].should == subject
+          end.and_call_original
+        end
+      end
+
+      describe "#send" do
+        it "should raise a NotImplementedError exception" do
+          expect { subject.send :message }.to raise_exception(NotImplementedError)
+        end
+      end
+
+      describe "#user_connection?" do
+        context "when a user is signed in" do
+          before do
+            subject.stub(:user_identifier).and_return("Jimbo Jones")
+          end
+
+          it "returns true" do
+            subject.user_connection?.should == true
+          end
+        end
+
+        context "when a user is signed out" do
+          before do
+            subject.stub(:user_identifier).and_return(nil)
+          end
+
+          it "returns true" do
+            subject.user_connection?.should == false
+          end
+        end
+      end
+
+      describe "#user" do
+        it "provides access to the current_user object" do
+          user = double('User')
+          subject.stub(:user_identifier).and_return true
+          subject.stub_chain(:controller_delegate, :current_user).and_return user
+          subject.user.should == user
+        end
+      end
+
+      describe "#enqueue" do
+        it "should add the event to the queue" do
+          subject.enqueue 'event'
+          subject.queue.queue.should == ['event']
+        end
+      end
+
+      describe "#flush" do
+        before do
+          event = Event.new(:queued_event, data: 'test')
+          2.times { subject.enqueue event }
+        end
+
+        it "should serialize all events into one array" do
+          serialized_array = <<-EOF.strip_heredoc
+            [["queued_event",{"id":null,"channel":null,"user_id":null,"data":"test","success":null,"result":null,"token":null,"server_token":null}],
+            ["queued_event",{"id":null,"channel":null,"user_id":null,"data":"test","success":null,"result":null,"token":null,"server_token":null}]]
+          EOF
+
+          subject.should_receive(:send).with(serialized_array.gsub(/\n/,'').strip)
+          subject.flush
+        end
+      end
+
+      describe "#trigger" do
+        it "passes a serialized event to the connections #send method" do
+          event.stub(:serialize).and_return('test')
+          subject.should_receive(:send).with "[test]"
+          subject.trigger event
+        end
+      end
+
+      describe "#close_connection" do
+        before do
+          subject.stub(:user_identifier).and_return(1)
+          @connection_manager = double('connection_manager').as_null_object
+          subject.stub_chain(:dispatcher, :connection_manager).and_return(@connection_manager)
+        end
+
+        it "calls delegates to the conection manager" do
+          @connection_manager.should_receive(:close_connection).with(subject)
+          subject.__send__(:close_connection)
+        end
+
+        it "deletes it's data_store" do
+          subject.data_store.should_receive(:destroy!)
+          subject.__send__(:close_connection)
+        end
+      end
+    end
+  end
+end