websocket-rails 0.1.5 → 0.1.6

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

@@ -0,0 +1,232 @@
+(function() {
+
+  describe('WebSocketRails:', function() {
+    beforeEach(function() {
+      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;
+          }
+        };
+      };
+      return this.dispatcher = new WebSocketRails(this.url);
+    });
+    describe('constructor', 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);
+      });
+      it('should set the initial state to connecting', function() {
+        return expect(this.dispatcher.state).toEqual('connecting');
+      });
+      describe('when use_websockets is true', function() {
+        return it('should use the WebSocket Connection', function() {
+          var dispatcher;
+          dispatcher = new WebSocketRails(this.url, true);
+          return expect(dispatcher._conn.connection_type).toEqual('websocket');
+        });
+      });
+      describe('when use_webosckets is false', function() {
+        return it('should use the Http Connection', function() {
+          var dispatcher;
+          dispatcher = new WebSocketRails(this.url, false);
+          return expect(dispatcher._conn.connection_type).toEqual('http');
+        });
+      });
+      return describe('when the browser does not support WebSockets', function() {
+        return it('should use the Http Connection', function() {
+          var dispatcher;
+          window.WebSocket = 'undefined';
+          dispatcher = new WebSocketRails(this.url, true);
+          return expect(dispatcher._conn.connection_type).toEqual('http');
+        });
+      });
+    });
+    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]];
+        });
+        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);
+          return mock_dispatcher.verify();
+        });
+        it('should set the state to connected', function() {
+          this.dispatcher.new_message(this.data);
+          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);
+          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);
+        });
+        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);
+          return expect(spy.calledOnce).toEqual(true);
+        });
+      });
+      return describe('after the connection has been established', function() {
+        beforeEach(function() {
+          this.dispatcher.state = 'connected';
+          return this.attributes = {
+            data: 'message',
+            channel: 'channel'
+          };
+        });
+        it('should dispatch channel messages', function() {
+          var data, mock_dispatcher;
+          data = [['event', this.attributes]];
+          mock_dispatcher = sinon.mock(this.dispatcher);
+          mock_dispatcher.expects('dispatch_channel').once();
+          this.dispatcher.new_message(data);
+          return mock_dispatcher.verify();
+        });
+        it('should dispatch standard events', function() {
+          var data, mock_dispatcher;
+          data = [['event', 'message']];
+          mock_dispatcher = sinon.mock(this.dispatcher);
+          mock_dispatcher.expects('dispatch').once();
+          this.dispatcher.new_message(data);
+          return mock_dispatcher.verify();
+        });
+        return describe('result events', function() {
+          beforeEach(function() {
+            this.attributes['success'] = true;
+            this.attributes['id'] = 1;
+            this.event = {
+              run_callbacks: function(data) {}
+            };
+            this.event_mock = sinon.mock(this.event);
+            return this.dispatcher.queue[1] = this.event;
+          });
+          return it('should run callbacks for result events', function() {
+            var data;
+            data = [['event', this.attributes]];
+            this.event_mock.expects('run_callbacks').once();
+            this.dispatcher.new_message(data);
+            return this.event_mock.verify();
+          });
+        });
+      });
+    });
+    describe('.bind', function() {
+      return it('should store the callback on the correct event', function() {
+        var callback;
+        callback = function() {};
+        this.dispatcher.bind('event', callback);
+        return expect(this.dispatcher.callbacks['event']).toContain(callback);
+      });
+    });
+    describe('.dispatch', function() {
+      return it('should execute the callback for the correct event', function() {
+        var callback, event;
+        callback = sinon.spy();
+        event = new WebSocketRails.Event([
+          'event', {
+            data: 'message'
+          }
+        ]);
+        this.dispatcher.bind('event', callback);
+        this.dispatcher.dispatch(event);
+        return expect(callback.calledWith('message')).toEqual(true);
+      });
+    });
+    describe('triggering events with', function() {
+      beforeEach(function() {
+        this.dispatcher.connection_id = 123;
+        return this.dispatcher._conn = {
+          trigger: function() {},
+          trigger_channel: 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');
+          this.dispatcher.trigger('event', 'message');
+          event = new WebSocketRails.Event([
+            'websocket_rails.subscribe', {
+              channel: 'awesome'
+            }, 123
+          ]);
+          return expect(con_trigger.called).toEqual(true);
+        });
+      });
+    });
+    return describe('working with channels', function() {
+      beforeEach(function() {
+        return WebSocketRails.Channel = function(name, dispatcher, is_private) {
+          this.name = name;
+          this.dispatcher = dispatcher;
+          this.is_private = is_private;
+        };
+      });
+      describe('.subscribe', function() {
+        describe('for new channels', function() {
+          return it('should create and store a new Channel object', function() {
+            var channel;
+            channel = this.dispatcher.subscribe('test_channel');
+            return expect(channel.name).toEqual('test_channel');
+          });
+        });
+        return describe('for existing channels', function() {
+          return it('should return the same Channel object', function() {
+            var channel;
+            channel = this.dispatcher.subscribe('test_channel');
+            return expect(this.dispatcher.subscribe('test_channel')).toEqual(channel);
+          });
+        });
+      });
+      describe('.subscribe_private', function() {
+        return it('should create private channels', function() {
+          var private_channel;
+          private_channel = this.dispatcher.subscribe_private('private_something');
+          return expect(private_channel.is_private).toBe(true);
+        });
+      });
+      return describe('.dispatch_channel', function() {
+        return it('should delegate to the Channel object', function() {
+          var channel, event, spy;
+          channel = this.dispatcher.subscribe('test');
+          channel.dispatch = function() {};
+          spy = sinon.spy(channel, 'dispatch');
+          event = new WebSocketRails.Event([
+            'event', {
+              channel: 'test',
+              data: 'awesome'
+            }
+          ]);
+          this.dispatcher.dispatch_channel(event);
+          return expect(spy.calledWith('event', 'awesome')).toEqual(true);
+        });
+      });
+    });
+  });
+
+}).call(this);

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,44 @@
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_dir: spec/javascripts
+src_files:
+    - support/vendor/sinon-1.3.4.js
+    - generated/assets/websocket_rails.js
+    - generated/assets/*.js
+
+spec_dir: spec/javascripts/generated
+spec_files:
+    - specs/*_spec.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:

data/spec/javascripts/support/jasmine_config.rb

@@ -0,0 +1,63 @@
+# spec/javascripts/support/jasmine_config.rb
+# when jasmine starts the server out-of-process, it needs this in order to be able to invoke the asset tasks
+unless Object.const_defined?(:Rake)
+  require 'rake'
+  load File.expand_path('../../../../Rakefile', __FILE__)
+end
+
+require 'coffee_script'
+
+module Jasmine
+  class Config
+    include Rake::DSL
+
+    def js_files(spec_filter = nil)
+      # remove all generated files
+      generated_files_directory = File.expand_path("../../../../spec/javascripts/generated/assets", __FILE__)
+      rm_rf generated_files_directory, :secure => true
+
+      precompile_app_assets
+      compile_jasmine_javascripts
+
+      # this is code from the original jasmine config js_files method - you could also just alias_method_chain it
+      spec_files_to_include = spec_filter.nil? ? spec_files : match_files(spec_dir, [spec_filter])
+      src_files.collect {|f| "/" + f } + helpers.collect {|f| File.join(spec_path, f) } + spec_files_to_include.collect {|f| File.join(spec_path, f) }
+    end
+
+    private
+
+    # this method compiles all the same javascript files your app will
+    def precompile_app_assets
+      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
+    end
+
+    # this method compiles all of the spec files into js files that jasmine can run
+    def compile_jasmine_javascripts
+      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
+    end
+
+  end
+end