websocket-rails 0.6.2 → 0.7.0

data/spec/javascripts/generated/specs/websocket_connection_spec.js

@@ -1,8 +1,13 @@
 (function() {
   describe('WebsocketRails.WebSocketConnection:', function() {
+    var SAMPLE_EVENT, SAMPLE_EVENT_DATA;
+    SAMPLE_EVENT_DATA = ['event', 'message'];
+    SAMPLE_EVENT = {
+      data: JSON.stringify(SAMPLE_EVENT_DATA)
+    };
     beforeEach(function() {
-      var dispatcher;
-      dispatcher = {
+      var WebSocketStub;
+      this.dispatcher = {
         new_message: function() {
           return true;
         },
@@ -11,21 +16,40 @@
         },
         state: 'connected'
       };
-      window.WebSocket = function(url) {
-        this.url = url;
-        return this.send = function() {
+      window.WebSocket = WebSocketStub = (function() {
+        function WebSocketStub(url, dispatcher) {
+          this.url = url;
+          this.dispatcher = dispatcher;
+        }
+
+        WebSocketStub.prototype.send = function() {
           return true;
         };
-      };
-      this.dispatcher = dispatcher;
-      return this.connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', dispatcher);
+
+        WebSocketStub.prototype.close = function() {
+          return this.onclose(null);
+        };
+
+        return WebSocketStub;
+
+      })();
+      this.connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', this.dispatcher);
+      return this.dispatcher._conn = this.connection;
     });
     describe('constructor', function() {
-      it('should set the onmessage event on the WebSocket object to this.on_message', function() {
-        return expect(this.connection._conn.onmessage).toEqual(this.connection.on_message);
+      it('should redirect onmessage events\' data from the WebSocket object to this.on_message', function() {
+        var mock_connection;
+        mock_connection = sinon.mock(this.connection);
+        mock_connection.expects('on_message').once().withArgs(SAMPLE_EVENT_DATA);
+        this.connection._conn.onmessage(SAMPLE_EVENT);
+        return mock_connection.verify();
       });
-      it('should set the onclose event on the WebSocket object to this.on_close', function() {
-        return expect(this.connection._conn.onclose).toEqual(this.connection.on_close);
+      it('should redirect onclose events from the WebSocket object to this.on_close', function() {
+        var mock_connection;
+        mock_connection = sinon.mock(this.connection);
+        mock_connection.expects('on_close').once().withArgs(SAMPLE_EVENT);
+        this.connection._conn.onclose(SAMPLE_EVENT);
+        return mock_connection.verify();
       });
       describe('with ssl', function() {
         return it('should not add the ws:// prefix to the URL', function() {
@@ -40,6 +64,12 @@
         });
       });
     });
+    describe('.close', function() {
+      return it('should close the connection', function() {
+        this.connection.close();
+        return expect(this.dispatcher.state).toEqual('disconnected');
+      });
+    });
     describe('.trigger', function() {
       describe('before the connection has been fully established', function() {
         return it('should queue up the events', function() {
@@ -69,14 +99,10 @@
     });
     describe('.on_message', function() {
       return it('should decode the message and pass it to the dispatcher', function() {
-        var encoded_data, event, mock_dispatcher;
-        encoded_data = JSON.stringify(['event', 'message']);
-        event = {
-          data: encoded_data
-        };
+        var mock_dispatcher;
         mock_dispatcher = sinon.mock(this.connection.dispatcher);
-        mock_dispatcher.expects('new_message').once().withArgs(JSON.parse(encoded_data));
-        this.connection.on_message(event);
+        mock_dispatcher.expects('new_message').once().withArgs(SAMPLE_EVENT_DATA);
+        this.connection.on_message(SAMPLE_EVENT_DATA);
         return mock_dispatcher.verify();
       });
     });
@@ -120,6 +146,33 @@
         return expect(this.dispatcher.state).toEqual('disconnected');
       });
     });
+    describe("it's no longer active connection", function() {
+      beforeEach(function() {
+        this.new_connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', this.dispatcher);
+        return this.dispatcher._conn = this.new_connection;
+      });
+      it(".on_error should not react to the event response", function() {
+        var mock_dispatcher;
+        mock_dispatcher = sinon.mock(this.connection.dispatcher);
+        mock_dispatcher.expects('dispatch').never();
+        this.connection.on_error(SAMPLE_EVENT_DATA);
+        return mock_dispatcher.verify();
+      });
+      it(".on_close should not react to the event response", function() {
+        var mock_dispatcher;
+        mock_dispatcher = sinon.mock(this.connection.dispatcher);
+        mock_dispatcher.expects('dispatch').never();
+        this.connection.on_close(SAMPLE_EVENT_DATA);
+        return mock_dispatcher.verify();
+      });
+      return it(".on_message should not react to the event response", function() {
+        var mock_dispatcher;
+        mock_dispatcher = sinon.mock(this.connection.dispatcher);
+        mock_dispatcher.expects('new_message').never();
+        this.connection.on_message(SAMPLE_EVENT_DATA);
+        return mock_dispatcher.verify();
+      });
+    });
     return describe('.flush_queue', function() {
       beforeEach(function() {
         this.event = new WebSocketRails.Event(['event', 'message']);

data/spec/javascripts/generated/specs/websocket_rails_spec.js

@@ -1,26 +1,43 @@
 (function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
   describe('WebSocketRails:', function() {
     beforeEach(function() {
+      var HttpConnectionStub, WebSocketConnectionStub;
       this.url = 'localhost:3000/websocket';
-      WebSocketRails.WebSocketConnection = function() {
-        return {
-          connection_type: 'websocket',
-          flush_queue: function() {
-            return true;
-          }
-        };
-      };
-      WebSocketRails.HttpConnection = function() {
-        return {
-          connection_type: 'http',
-          flush_queue: function() {
-            return true;
-          }
-        };
-      };
+      WebSocketRails.WebSocketConnection = WebSocketConnectionStub = (function(_super) {
+        __extends(WebSocketConnectionStub, _super);
+
+        function WebSocketConnectionStub() {
+          return WebSocketConnectionStub.__super__.constructor.apply(this, arguments);
+        }
+
+        WebSocketConnectionStub.prototype.connection_type = 'websocket';
+
+        return WebSocketConnectionStub;
+
+      })(WebSocketRails.AbstractConnection);
+      WebSocketRails.HttpConnection = HttpConnectionStub = (function(_super) {
+        __extends(HttpConnectionStub, _super);
+
+        function HttpConnectionStub() {
+          return HttpConnectionStub.__super__.constructor.apply(this, arguments);
+        }
+
+        HttpConnectionStub.prototype.connection_type = 'http';
+
+        return HttpConnectionStub;
+
+      })(WebSocketRails.AbstractConnection);
       return this.dispatcher = new WebSocketRails(this.url);
     });
     describe('constructor', function() {
+      return it('should start connection automatically', function() {
+        return expect(this.dispatcher.state).toEqual('connecting');
+      });
+    });
+    describe('.connect', function() {
       it('should set the new_message method on connection to this.new_message', function() {
         return expect(this.dispatcher._conn.new_message).toEqual(this.dispatcher.new_message);
       });
@@ -34,7 +51,7 @@
           return expect(dispatcher._conn.connection_type).toEqual('websocket');
         });
       });
-      describe('when use_webosckets is false', function() {
+      describe('when use_websockets is false', function() {
         return it('should use the Http Connection', function() {
           var dispatcher;
           dispatcher = new WebSocketRails(this.url, false);
@@ -50,43 +67,119 @@
         });
       });
     });
+    describe('.disconnect', function() {
+      beforeEach(function() {
+        return this.dispatcher.disconnect();
+      });
+      it('should close the connection', function() {
+        return expect(this.dispatcher.state).toEqual('disconnected');
+      });
+      return it('existing connection should be destroyed', function() {
+        return expect(this.dispatcher._conn).toBeUndefined();
+      });
+    });
+    describe('.reconnect', function() {
+      var NEW_CONNECTION_ID, OLD_CONNECTION_ID;
+      OLD_CONNECTION_ID = 1;
+      NEW_CONNECTION_ID = 2;
+      it('should connect, when disconnected', function() {
+        var mock_dispatcher;
+        mock_dispatcher = sinon.mock(this.dispatcher);
+        mock_dispatcher.expects('connect').once();
+        this.dispatcher.disconnect();
+        this.dispatcher.reconnect();
+        return mock_dispatcher.verify();
+      });
+      it('should recreate the connection', function() {
+        helpers.startConnection(this.dispatcher, OLD_CONNECTION_ID);
+        this.dispatcher.reconnect();
+        helpers.startConnection(this.dispatcher, NEW_CONNECTION_ID);
+        return expect(this.dispatcher._conn.connection_id).toEqual(NEW_CONNECTION_ID);
+      });
+      it('should resend all uncompleted events', function() {
+        var event;
+        event = this.dispatcher.trigger('create_post');
+        helpers.startConnection(this.dispatcher, OLD_CONNECTION_ID);
+        this.dispatcher.reconnect();
+        helpers.startConnection(this.dispatcher, NEW_CONNECTION_ID);
+        return expect(this.dispatcher.queue[event.id].connection_id).toEqual(NEW_CONNECTION_ID);
+      });
+      it('should not resend completed events', function() {
+        var event;
+        event = this.dispatcher.trigger('create_post');
+        event.run_callbacks(true, {});
+        helpers.startConnection(this.dispatcher, OLD_CONNECTION_ID);
+        this.dispatcher.reconnect();
+        helpers.startConnection(this.dispatcher, NEW_CONNECTION_ID);
+        return expect(this.dispatcher.queue[event.id].connection_id).toEqual(OLD_CONNECTION_ID);
+      });
+      return it('should reconnect to all channels', function() {
+        var mock_dispatcher;
+        mock_dispatcher = sinon.mock(this.dispatcher);
+        mock_dispatcher.expects('reconnect_channels').once();
+        this.dispatcher.reconnect();
+        return mock_dispatcher.verify();
+      });
+    });
+    describe('.reconnect_channels', function() {
+      beforeEach(function() {
+        this.channel_callback = function() {
+          return true;
+        };
+        helpers.startConnection(this.dispatcher, 1);
+        this.dispatcher.subscribe('public 4chan');
+        this.dispatcher.subscribe_private('private 4chan');
+        return this.dispatcher.channels['public 4chan'].bind('new_post', this.channel_callback);
+      });
+      it('should recreate existing channels, keeping their private/public type', function() {
+        this.dispatcher.reconnect_channels();
+        expect(this.dispatcher.channels['public 4chan'].is_private).toEqual(false);
+        return expect(this.dispatcher.channels['private 4chan'].is_private).toEqual(true);
+      });
+      return it('should move all existing callbacks from old channel objects to new ones', function() {
+        var old_public_channel;
+        old_public_channel = this.dispatcher.channels['public 4chan'];
+        this.dispatcher.reconnect_channels();
+        expect(old_public_channel._callbacks).toEqual({});
+        return expect(this.dispatcher.channels['public 4chan']._callbacks).toEqual({
+          new_post: [this.channel_callback]
+        });
+      });
+    });
     describe('.new_message', function() {
       describe('when this.state is "connecting"', function() {
         beforeEach(function() {
-          this.message = {
-            data: {
-              connection_id: 123
-            }
-          };
-          return this.data = [['client_connected', this.message]];
+          return this.connection_id = 123;
         });
         it('should call this.connection_established on the "client_connected" event', function() {
           var mock_dispatcher;
           mock_dispatcher = sinon.mock(this.dispatcher);
-          mock_dispatcher.expects('connection_established').once().withArgs(this.message.data);
-          this.dispatcher.new_message(this.data);
+          mock_dispatcher.expects('connection_established').once().withArgs({
+            connection_id: this.connection_id
+          });
+          helpers.startConnection(this.dispatcher, this.connection_id);
           return mock_dispatcher.verify();
         });
         it('should set the state to connected', function() {
-          this.dispatcher.new_message(this.data);
+          helpers.startConnection(this.dispatcher, this.connection_id);
           return expect(this.dispatcher.state).toEqual('connected');
         });
         it('should flush any messages queued before the connection was established', function() {
           var mock_con;
           mock_con = sinon.mock(this.dispatcher._conn);
           mock_con.expects('flush_queue').once();
-          this.dispatcher.new_message(this.data);
+          helpers.startConnection(this.dispatcher, this.connection_id);
           return mock_con.verify();
         });
         it('should set the correct connection_id', function() {
-          this.dispatcher.new_message(this.data);
-          return expect(this.dispatcher.connection_id).toEqual(123);
+          helpers.startConnection(this.dispatcher, this.connection_id);
+          return expect(this.dispatcher._conn.connection_id).toEqual(123);
         });
         return it('should call the user defined on_open callback', function() {
           var spy;
           spy = sinon.spy();
           this.dispatcher.on_open = spy;
-          this.dispatcher.new_message(this.data);
+          helpers.startConnection(this.dispatcher, this.connection_id);
           return expect(spy.calledOnce).toEqual(true);
         });
       });
@@ -122,15 +215,18 @@
               run_callbacks: function(data) {}
             };
             this.event_mock = sinon.mock(this.event);
-            return this.dispatcher.queue[1] = this.event;
+            this.dispatcher.queue[1] = this.event;
+            return this.event_data = [['event', this.attributes]];
           });
-          return it('should run callbacks for result events', function() {
-            var data;
-            data = [['event', this.attributes]];
+          it('should run callbacks for result events', function() {
             this.event_mock.expects('run_callbacks').once();
-            this.dispatcher.new_message(data);
+            this.dispatcher.new_message(this.event_data);
             return this.event_mock.verify();
           });
+          return it('should remove the event from the queue', function() {
+            this.dispatcher.new_message(this.event_data);
+            return expect(this.dispatcher.queue[1]).toBeUndefined();
+          });
         });
       });
     });
@@ -158,23 +254,26 @@
     });
     describe('triggering events with', function() {
       beforeEach(function() {
-        this.dispatcher.connection_id = 123;
         return this.dispatcher._conn = {
-          trigger: function() {},
-          trigger_channel: function() {}
+          connection_id: 123,
+          trigger: function() {}
         };
       });
       return describe('.trigger', function() {
-        return it('should delegate to the connection object', function() {
-          var con_trigger, event;
-          con_trigger = sinon.spy(this.dispatcher._conn, 'trigger');
+        it('should add the event to the queue', function() {
+          var event;
+          event = this.dispatcher.trigger('event', 'message');
+          return expect(this.dispatcher.queue[event.id]).toEqual(event);
+        });
+        it('should delegate to the connection object', function() {
+          var conn_trigger;
+          conn_trigger = sinon.spy(this.dispatcher._conn, 'trigger');
           this.dispatcher.trigger('event', 'message');
-          event = new WebSocketRails.Event([
-            'websocket_rails.subscribe', {
-              channel: 'awesome'
-            }, 123
-          ]);
-          return expect(con_trigger.called).toEqual(true);
+          return expect(conn_trigger.called).toEqual(true);
+        });
+        return it("should not delegate to the connection object, if it's not available", function() {
+          this.dispatcher._conn = null;
+          return this.dispatcher.trigger('event', 'message');
         });
       });
     });

data/spec/javascripts/support/jasmine.yml

@@ -12,11 +12,19 @@ src_dir: spec/javascripts
 src_files:
     - support/vendor/sinon-1.7.1.js
     - generated/assets/websocket_rails.js
-    - generated/assets/*.js
+    - generated/assets/event.js
+    - generated/assets/abstract_connection.js
+    - generated/assets/http_connection.js
+    - generated/assets/websocket_connection.js
+    - generated/assets/channel.js
+    - generated/specs/helpers.js
 
 spec_dir: spec/javascripts/generated
 spec_files:
-    - specs/*_spec.js
+    - specs/event_spec.js
+    - specs/websocket_connection_spec.js
+    - specs/channel_spec.js
+    - specs/websocket_rails_spec.js
 
 # stylesheets
 #

data/spec/javascripts/support/jasmine_helper.rb

@@ -0,0 +1,38 @@
+#Use this file to set/override Jasmine configuration options
+#You can remove it if you don't need it.
+#This file is loaded *after* jasmine.yml is interpreted.
+#
+#Example: using a different boot file.
+#Jasmine.configure do |config|
+#   config.boot_dir = '/absolute/path/to/boot_dir'
+#   config.boot_files = lambda { ['/absolute/path/to/boot_dir/file.js'] }
+#end
+#
+require 'coffee-script'
+
+puts "Precompiling assets..."
+
+root = File.expand_path("../../../../lib/assets/javascripts/websocket_rails", __FILE__)
+destination_dir = File.expand_path("../../../../spec/javascripts/generated/assets", __FILE__)
+
+glob = File.expand_path("**/*.js.coffee", root)
+
+Dir.glob(glob).each do |srcfile|
+  srcfile = Pathname.new(srcfile)
+  destfile = srcfile.sub(root, destination_dir).sub(".coffee", "")
+  FileUtils.mkdir_p(destfile.dirname)
+  File.open(destfile, "w") {|f| f.write(CoffeeScript.compile(File.new(srcfile)))}
+end
+puts "Compiling jasmine coffee scripts into javascript..."
+root = File.expand_path("../../../../spec/javascripts/websocket_rails", __FILE__)
+destination_dir = File.expand_path("../../generated/specs", __FILE__)
+
+glob = File.expand_path("**/*.coffee", root)
+
+Dir.glob(glob).each do |srcfile|
+  srcfile = Pathname.new(srcfile)
+  destfile = srcfile.sub(root, destination_dir).sub(".coffee", ".js")
+  FileUtils.mkdir_p(destfile.dirname)
+  File.open(destfile, "w") {|f| f.write(CoffeeScript.compile(File.new(srcfile)))}
+end
+