hkroger-websocket-rails 0.7.1

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

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