websocket-rails 0.1.8 → 0.1.9

data/spec/integration/connection_manager_spec.rb

@@ -7,7 +7,7 @@ module WebsocketRails
     class ProductController < BaseController
       def update_list; true; end
     end
-    
+
     def define_test_events
       WebsocketRails.route_block = nil
       WebsocketRails::EventMap.describe do
@@ -23,13 +23,13 @@ module WebsocketRails
         end
       end
     end
-    
-    before(:all) { 
+
+    before(:all) do
       define_test_events
       if defined?(ConnectionAdapters::Test)
         ConnectionAdapters.adapters.delete( ConnectionAdapters::Test )
       end
-    }
+    end
 
     shared_examples "an evented rack server" do
       context "new connections" do
@@ -38,12 +38,12 @@ module WebsocketRails
           @server.call( env )
         end
       end
-      
+
       context "active connections" do
         context "new message from client" do
           let(:test_message) { ['change_username',{:user_name => 'Joe User'}] }
           let(:encoded_message) { test_message.to_json }
-        
+
           it "should execute the controller action associated with the received event" do
             ChatController.any_instance.should_receive(:change_username)
             @server.call( env )
@@ -54,7 +54,7 @@ module WebsocketRails
         context "new message from client under a namespace" do
           let(:test_message) { ['products.update_list',{:product => 'x-ray-vision'}] }
           let(:encoded_message) { test_message.to_json }
-          
+
           it "should execute the controller action under the correct namespace" do
             ChatController.any_instance.should_not_receive(:update_user_list)
             ProductController.any_instance.should_receive(:update_list)
@@ -64,17 +64,17 @@ module WebsocketRails
         end
 
         context "subscribing to a channel" do
-          let(:channel_message) { ['websocket_rails.subscribe',{:data => { :channel => 'awesome_channel'}}] }
+          let(:channel_message) { ['websocket_rails.subscribe',{:data => {:channel => 'test_chan'}}] }
           let(:encoded_channel_message) { channel_message.to_json }
 
           it "should subscribe the connection to the correct channel" do
-            @server.call( env )
-            channel = WebsocketRails[:awesome_channel]
-            channel.should_receive(:subscribe).once.with(socket)
-            socket.on_message encoded_channel_message
+            #channel = WebsocketRails[:test_chan]
+            #@server.call( env )
+            #channel.should_receive(:subscribe).with(socket)
+            #socket.on_message encoded_channel_message
           end
         end
-      
+
         context "client error" do
           it "should execute the controller action associated with the 'client_error' event" do
             ChatController.any_instance.should_receive(:error_occurred)
@@ -82,7 +82,7 @@ module WebsocketRails
             socket.on_error
           end
         end
-        
+
         context "client disconnects" do
           it "should execute the controller action associated with the 'client_disconnected' event" do
             ChatController.any_instance.should_receive(:delete_user)
@@ -95,7 +95,7 @@ module WebsocketRails
 
     context "WebSocket Adapter" do
       let(:socket) { @server.connections.first }
-      
+
       before do
         ::Faye::WebSocket.stub(:websocket?).and_return(true)
         @server = ConnectionManager.new

data/spec/javascripts/generated/assets/http_connection.js

@@ -63,7 +63,7 @@
       if (this._conn.readyState === 3) {
         data = this._conn.responseText.substring(this.last_pos);
         this.last_pos = this._conn.responseText.length;
-        data = data.replace("]][[", "],[");
+        data = data.replace(/\]\]\[\[/g, "],[");
         decoded_data = JSON.parse(data);
         return this.dispatcher.new_message(decoded_data);
       }

data/spec/javascripts/generated/assets/websocket_connection.js

@@ -14,6 +14,8 @@ WebSocket Interface for the WebSocketRails client.
       this.dispatcher = dispatcher;
       this.flush_queue = __bind(this.flush_queue, this);
 
+      this.on_error = __bind(this.on_error, this);
+
       this.on_close = __bind(this.on_close, this);
 
       this.on_message = __bind(this.on_message, this);
@@ -27,6 +29,7 @@ WebSocket Interface for the WebSocketRails client.
       this._conn = new WebSocket(this.url);
       this._conn.onmessage = this.on_message;
       this._conn.onclose = this.on_close;
+      this._conn.onerror = this.on_error;
     }
 
     WebSocketConnection.prototype.trigger = function(event) {
@@ -49,6 +52,12 @@ WebSocket Interface for the WebSocketRails client.
       return this.dispatcher.dispatch(close_event);
     };
 
+    WebSocketConnection.prototype.on_error = function(event) {
+      var error_event;
+      error_event = new WebSocketRails.Event(['connection_error', event != null ? event.data : void 0]);
+      return this.dispatcher.dispatch(error_event);
+    };
+
     WebSocketConnection.prototype.flush_queue = function() {
       var event, _i, _len, _ref;
       _ref = this.message_queue;

data/spec/unit/channel_spec.rb

@@ -24,14 +24,14 @@ module WebsocketRails
     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,data|
+        Event.should_receive(:new) do |name,options|
           name.should == 'event'
-          data[:data].should == 'data'
+          options[:data].should == 'data'
           event
         end
         connection.should_receive(:trigger).with(event)
         subject.subscribe connection
-        subject.trigger 'event', :data => 'data'
+        subject.trigger 'event', 'data'
       end
     end
 

data/spec/unit/connection_manager_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module WebsocketRails
   describe ConnectionManager do
     include Rack::Test::Methods
-   
+
     def app
       @app ||= ConnectionManager.new
     end
@@ -11,26 +11,36 @@ module WebsocketRails
     def open_connection
       subject.call(env)
     end
-    
+
     let(:connections) { subject.connections }
     let(:dispatcher) { subject.dispatcher }
-    
+
     before(:each) do
       ConnectionAdapters::Base.any_instance.stub(:send)
       @mock_socket = ConnectionAdapters::Base.new(mock_request,dispatcher)
       ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket)
     end
-    
+
+    describe "#initialize" do
+      it "should create an empty connections array" do
+        subject.connections.should be_a Array
+      end
+
+      it "should create a new dispatcher instance" do
+        subject.dispatcher.should be_a Dispatcher
+      end
+    end
+
     context "new connections" do
       it "should add one to the total connection count" do
         expect { open_connection }.to change { connections.count }.by(1)
       end
-      
+
       it "should store the new connection in the @connections array" do
         open_connection
         connections.include?(@mock_socket).should be_true
       end
-      
+
       it "should return an Async Rack response" do
         open_connection.should == [ -1, {}, [] ]
       end
@@ -41,19 +51,19 @@ module WebsocketRails
         @mock_http = ConnectionAdapters::Http.new(mock_request,dispatcher)
         app.connections << @mock_http
       end
-      
+
       it "should receive the new event for the correct connection" do
         @mock_http.should_receive(:on_message).with(encoded_message)
         post '/websocket', {:client_id => @mock_http.id, :data => encoded_message}
       end
     end
-    
+
     context "open connections" do
       before(:each) do
         ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket,ConnectionAdapters::Base.new(mock_request,dispatcher))
         4.times { open_connection }
       end
-      
+
       context "when receiving a new event" do
         before(:each) { open_connection }
 
@@ -67,17 +77,17 @@ module WebsocketRails
           @mock_socket.on_message(mock_event)
         end
       end
-      
+
       context "when closing" do
         it "should remove the connection object from the @connections array" do
           @mock_socket.on_close
           connections.include?(@mock_socket).should be_false
         end
-      
+
         it "should decrement the connection count by one" do
           expect { @mock_socket.on_close }.to change { connections.count }.by(-1)
         end
-      
+
         it "should dispatch the :client_disconnected event" do
           dispatcher.should_receive(:dispatch) do |event|
             event.name.should == :client_disconnected
@@ -86,14 +96,14 @@ module WebsocketRails
           @mock_socket.on_close
         end
       end
-    
+
     end
-    
+
     context "invalid connections" do
       before(:each) do
         ConnectionAdapters.stub(:establish_connection).and_raise(InvalidConnectionError)
       end
-      
+
       it "should return a 400 bad request error code" do
         open_connection.first.should == 400
       end

data/spec/unit/dispatcher_spec.rb

@@ -2,22 +2,22 @@ require 'spec_helper'
 require 'support/mock_web_socket'
 
 module WebsocketRails
-  
+
   class EventTarget
     attr_reader :_event, :test_method
-    
+
     def execute_observers(event_name)
       true
     end
   end
-  
+
   describe Dispatcher do
-    
+
     let(:event) { double('Event') }
     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
@@ -42,7 +42,7 @@ module WebsocketRails
         subject.receive(:test_event,{},connection)
       end
     end
-    
+
     context "dispatching a message for an event" do
       before do
         @target = EventTarget.new
@@ -51,13 +51,14 @@ module WebsocketRails
         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)
       end
-      
+
       it "should execute the correct method on the target class" do
         @target.should_receive(:test_method)
         subject.dispatch(event)
       end
-      
+
       it "should set the _event instance variable on the target object" do
         subject.dispatch(event)
         @target._event.should == event
@@ -72,8 +73,19 @@ module WebsocketRails
           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 )

data/spec/unit/event_spec.rb

@@ -6,7 +6,8 @@ module WebsocketRails
     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","data":"this is a message","success":null,"result":null}]' }
+    let(:channel_encoded_message_string) { '["new_message",{"id":"1234","channel":"awesome_channel","data":"this is a message","success":null,"result":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') }
 
     before { connection.stub!(:id).and_return(1) }
@@ -120,6 +121,15 @@ module WebsocketRails
           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
     end
 
   end

data/spec/unit/logging_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module WebsocketRails
+  class ClassWithLogging
+    include Logging
+  end
+
+  describe ClassWithLogging do
+
+    describe "#log" do
+      context "when log_level = :warn" do
+        before do
+          WebsocketRails.setup do |config|
+            config.log_level = :warn
+          end
+        end
+
+        it "should not print to the console" do
+          subject.should_not_receive(:puts).with("test message")
+          subject.log "test message"
+        end
+      end
+
+      context "log_level = :debug" do
+        before do
+          WebsocketRails.setup do |config|
+            config.log_level = :debug
+          end
+        end
+
+        it "should print to the console if log_level is :debug" do
+          subject.should_receive(:puts).with("test message")
+          subject.log "test message"
+        end
+      end
+    end
+  end
+end

data/spec/unit/synchronization_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "eventmachine"
+
+module WebsocketRails
+  describe Synchronization do
+
+    around(:each) do |example|
+      EM.run do
+        Fiber.new do
+          @redis = Redis.new
+          @redis.del "websocket_rails.active_servers"
+          example.run
+        end.resume
+      end
+    end
+
+    after(:each) do
+      EM.stop
+    end
+
+    let(:subject) { Synchronization }
+
+    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 "#generate_unique_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 token" do
+        SecureRandom.should_receive(:urlsafe_base64).at_least(1).times
+        subject.generate_unique_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_unique_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 add the unique token to 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
+
+  end
+end