faye 0.7.2 → 0.8.0

data/spec/javascript/server_spec.js

@@ -27,16 +27,13 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
     it("ignores invalid messages", function() { with(this) {
       var response = null
       server.process([{}, {channel: "invalid"}], false, function(r) { response = r})
-      assertEqual( [], response )
-    }})
-
-    it("rejects unknown meta channels", function() { with(this) {
-      var response = null
-      server.process([{channel: "/meta/p"}], false, function(r) { response = r })
       assertEqual([
-        { channel:    "/meta/p",
+        { successful: false,
+          error:      "405::Invalid channel"
+        },
+        { channel:    "invalid",
           successful: false,
-          error:      "403:/meta/p:Forbidden channel"
+          error:      "405:invalid:Invalid channel"
         }
       ], response)
     }})
@@ -64,49 +61,6 @@ JS.ENV.ServerSpec = JS.Test.describe("Server", function() { with(this) {
       server.process([handshake, connect, disconnect, subscribe, unsubscribe, publish], false, function() {})
     }})
     
-    describe("publishing a message", function() { with(this) {
-      it("tells the engine to publish the message", function() { with(this) {
-        expect(engine, "publish").given(publish)
-        server.process(publish, false, function() {})
-      }})
-      
-      it("returns no response", function() { with(this) {
-        stub(engine, "publish")
-        server.process(publish, false, function(response) {
-          assertEqual( [], response)
-        })
-      }})
-      
-      describe("with an error", function() { with(this) {
-        before(function() { with(this) {
-          publish.error = "invalid"
-        }})
-        
-        it("does not tell the engine to publish the message", function() { with(this) {
-          expect(engine, "publish").exactly(0)
-          server.process(publish, false, function() {})
-        }})
-        
-        it("returns no response", function() { with(this) {
-          stub(engine, "publish")
-          server.process(publish, false, function(response) {
-            assertEqual( [], response)
-          })
-        }})
-      }})
-
-      describe("to an invalid channel", function() { with(this) {
-        before(function() { with(this) {
-          publish.channel = "/invalid/*"
-        }})
-
-        it("does not tell the engine to publish the message", function() { with(this) {
-          expect(engine, "publish").exactly(0)
-          server.process(publish, false, function() {})
-        }})
-      }})
-    }})
-    
     describe("handshaking", function() { with(this) {
       before(function() { with(this) {
         expect(server, "handshake").given(handshake, false).yielding([{channel: "/meta/handshake", successful: true}])

data/spec/node.js

@@ -1,8 +1,8 @@
-JSCLASS_PATH = 'vendor/js.class/build/src'
-require('../' + JSCLASS_PATH + '/loader')
+require('jsclass')
+Faye = require('../build/faye-node')
+Faye.logger = function() {}
 
 JS.Packages(function() { with(this) {
-  file('build/faye-node.js').provides('Faye')
   autoload(/.*Spec/, {from: 'spec/javascript'})
 }})
 
@@ -30,23 +30,23 @@ JS.require('Faye', 'JS.Test', 'JS.Range', function() {
     }
   })
   
+  JS.ENV.Engine = {}
   JS.ENV.Server = {}
   
   JS.require( 'FayeSpec',
               'GrammarSpec',
               'ChannelSpec',
               'EngineSpec',
+              'Engine.MemorySpec',
               'ServerSpec',
               'Server.HandshakeSpec',
               'Server.ConnectSpec',
               'Server.DisconnectSpec',
               'Server.SubscribeSpec',
               'Server.UnsubscribeSpec',
+              'Server.PublishSpec',
               'Server.ExtensionsSpec',
               'Server.IntegrationSpec',
-              'WebSocket.ClientSpec',
-              'WebSocket.Draft75ParserSpec',
-              'WebSocket.Protocol8ParserSpec',
               'NodeAdapterSpec',
               'ClientSpec',
               'TransportSpec',

data/spec/ruby/client_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Faye::Client do
   let :transport do
-    transport = mock("transport")
+    transport = mock("transport", :cookies= => nil, :headers= => nil)
     transport.stub(:connection_type).and_return "fake"
     transport.stub(:send)
     transport.extend(Faye::Publisher)

data/spec/ruby/engine/memory_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe Faye::Engine::Memory do
+  let(:engine_opts)  { {:type => Faye::Engine::Memory} }
+  it_should_behave_like "faye engine"
+end
+

data/spec/ruby/{engine_spec.rb → engine_examples.rb}

@@ -1,6 +1,17 @@
 # encoding=utf-8
 
-require "spec_helper"
+root = File.expand_path('../../..', __FILE__)
+
+require root + '/vendor/em-rspec/lib/em-rspec'
+require root + '/spec/encoding_helper'
+
+require root + '/lib/faye/mixins/logging'
+require root + '/lib/faye/mixins/publisher'
+require root + '/lib/faye/mixins/timeouts'
+
+require root + '/lib/faye/protocol/channel'
+require root + '/lib/faye/protocol/grammar'
+require root + '/lib/faye/engines/proxy'
 
 EngineSteps = EM::RSpec.async_steps do
   def create_client(name, &resume)
@@ -57,14 +68,14 @@ EngineSteps = EM::RSpec.async_steps do
   def publish(messages, &resume)
     messages = [messages].flatten
     messages.each do |message|
-      message = {"id" => Faye.random}.merge(message)
+      message = {"id" => Faye::Engine.random}.merge(message)
       engine.publish(message)
     end
     EM.add_timer(0.01, &resume)
   end
   
   def publish_by(name, message, &resume)
-    message = {"clientId" => @clients[name], "id" => Faye.random}.merge(message)
+    message = {"clientId" => @clients[name], "id" => Faye::Engine.random}.merge(message)
     engine.publish(message)
     EM.add_timer(0.01, &resume)
   end
@@ -109,28 +120,24 @@ EngineSteps = EM::RSpec.async_steps do
     @inboxes[a].first.should_not be_equal(@inboxes[b].first)
     resume.call
   end
-  
-  def clean_redis_db(&resume)
-    engine.disconnect
-    redis = EM::Hiredis::Client.connect
-    redis.flushall(&resume)
-  end
 end
 
 describe "Pub/sub engines" do
-  def create_engine
-    engine_klass.new(options.merge(engine_opts))
-  end
-  
   shared_examples_for "faye engine" do
     include EncodingHelper
     include EngineSteps
     
+    def create_engine
+      opts = options.merge(engine_opts)
+      Faye::Engine::Proxy.new(opts)
+    end
+    
     let(:options) { {:timeout => 1} }
     let(:engine) { create_engine }
     
     before do
-      Faye.ensure_reactor_running!
+      Faye.stub(:logger)
+      Faye::Engine.ensure_reactor_running!
       create_client :alice
       create_client :bob
       create_client :carol
@@ -382,6 +389,11 @@ describe "Pub/sub engines" do
   shared_examples_for "distributed engine" do
     include EngineSteps
     
+    def create_engine
+      opts = options.merge(engine_opts)
+      Faye::Engine::Proxy.new(opts)
+    end
+    
     let(:options) { {} }
     let(:left)  { create_engine }
     let(:right) { create_engine }
@@ -389,7 +401,8 @@ describe "Pub/sub engines" do
     alias :engine :left
     
     before do
-      Faye.ensure_reactor_running!
+      Faye.stub(:logger)
+      Faye::Engine.ensure_reactor_running!
       create_client :alice
       create_client :bob
       
@@ -410,24 +423,5 @@ describe "Pub/sub engines" do
       end
     end
   end
-  
-  describe Faye::Engine::Memory do
-    let(:engine_klass) { Faye::Engine::Memory }
-    let(:engine_opts)  { {} }
-    it_should_behave_like "faye engine"
-  end
-  
-  describe Faye::Engine::Redis do
-    let(:engine_klass) { Faye::Engine::Redis }
-    let(:engine_opts)  { {:password => "foobared", :namespace => Time.now.to_i.to_s} }
-    after { clean_redis_db }
-    it_should_behave_like "faye engine"
-    it_should_behave_like "distributed engine"
-    
-    describe "using a Unix socket" do
-      before { engine_opts[:socket] = "/tmp/redis.sock" }
-      it_should_behave_like "faye engine"
-    end
-  end
 end
 

data/spec/ruby/rack_adapter_spec.rb

@@ -13,7 +13,7 @@ describe Faye::RackAdapter do
   let(:content_type)          { last_response["Content-Type"] }
   let(:cache_control)         { last_response["Cache-Control"] }
   let(:access_control_origin) { last_response["Access-Control-Allow-Origin"] }
-  let(:json)                  { JSON.parse(body) }
+  let(:json)                  { Yajl::Parser.parse(body) }
   let(:body)                  { last_response.body }
   let(:status)                { last_response.status.to_i }
   

data/spec/ruby/server/handshake_spec.rb

@@ -4,6 +4,10 @@ describe "server handshake" do
   let(:engine) { mock "engine" }
   let(:server) { Faye::Server.new }
   
+  let :connection_types do
+    ["long-polling","cross-origin-long-polling","callback-polling","websocket","eventsource","in-process"]
+  end
+  
   before do
     Faye::Engine.stub(:get).and_return engine
   end
@@ -27,7 +31,7 @@ describe "server handshake" do
             "channel"    => "/meta/handshake",
             "successful" => true,
             "version"    => "1.0",
-            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket","in-process"],
+            "supportedConnectionTypes" => connection_types,
             "clientId"   => "clientid"
           }
         end
@@ -43,7 +47,7 @@ describe "server handshake" do
               "channel"    => "/meta/handshake",
               "successful" => true,
               "version"    => "1.0",
-              "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket","in-process"],
+              "supportedConnectionTypes" => connection_types,
               "clientId"   => "clientid",
               "id"         => "foo"
             }
@@ -67,7 +71,7 @@ describe "server handshake" do
             "successful" => false,
             "error"      => "402:version:Missing required parameter",
             "version"    => "1.0",
-            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket","in-process"]
+            "supportedConnectionTypes" => connection_types
           }
         end
       end
@@ -88,7 +92,7 @@ describe "server handshake" do
             "successful" => false,
             "error"      => "402:supportedConnectionTypes:Missing required parameter",
             "version"    => "1.0",
-            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket","in-process"]
+            "supportedConnectionTypes" => connection_types
           }
         end
       end
@@ -109,7 +113,7 @@ describe "server handshake" do
             "successful" => false,
             "error"      => "301:iframe,flash:Connection types not supported",
             "version"    => "1.0",
-            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket","in-process"]
+            "supportedConnectionTypes" => connection_types
           }
         end
       end
@@ -130,7 +134,7 @@ describe "server handshake" do
             "successful" => false,
             "error"      => "invalid",
             "version"    => "1.0",
-            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket","in-process"]
+            "supportedConnectionTypes" => connection_types
           }
         end
       end

data/spec/ruby/server/publish_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe "server publish" do
+  let(:engine)  { mock "engine" }
+  let(:server)  { Faye::Server.new }
+  let(:message) {{ "channel" => "/some/channel", "data" => "publish" }}
+  
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  
+  describe "publishing a message" do
+    it "tells the engine to publish the message" do
+      engine.should_receive(:publish).with(message)
+      server.process(message, false) {}
+    end
+    
+    it "returns a successful response" do
+      engine.stub(:publish)
+      server.process(message, false) do |response|
+        response.should == [
+          { "channel"     => "/some/channel",
+            "successful"  => true
+          }
+        ]
+      end
+    end
+    
+    describe "with an invalid channel" do
+      before { message["channel"] = "channel" }
+      
+      it "does not tell the engine to publish the message" do
+        engine.should_not_receive(:publish)
+        server.process(message, false) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        engine.stub(:publish)
+        server.process(message, false) do |response|
+          response.should == [
+            { "channel"     => "channel",
+              "successful"  => false,
+              "error"       => "405:channel:Invalid channel"
+            }
+          ]
+        end
+      end
+    end
+    
+    describe "with an error" do
+      before { message["error"] = "invalid" }
+      
+      it "does not tell the engine to publish the message" do
+        engine.should_not_receive(:publish)
+        server.process(message, false) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        engine.stub(:publish)
+        server.process(message, false) do |response|
+          response.should == [
+            { "channel"     => "/some/channel",
+              "successful"  => false,
+              "error"       => "invalid"
+            }
+          ]
+        end
+      end
+    end
+
+    describe "to an invalid channel" do
+      before { message["channel"] = "/invalid/*" }
+
+      it "does not tell the engine to publish the message" do
+        engine.should_not_receive(:publish)
+        server.process(message, false) {}
+      end
+    end
+  end
+end
+

data/spec/ruby/server_spec.rb

@@ -30,23 +30,20 @@ describe Faye::Server do
     it "ignores invalid messages" do
       response = nil
       server.process([{}, {"channel" => "invalid"}], false) { |r| response = r }
-      response.should == []
-    end
-
-    it "rejects unknown meta channels" do
-      response = nil
-      server.process([{"channel" => "/meta/p"}], false) { |r| response = r }
       response.should == [
-        { "channel"     => "/meta/p",
+        { "successful"  => false,
+          "error"       => "405::Invalid channel"
+        },
+        { "channel"     => "invalid",
           "successful"  => false,
-          "error"       => "403:/meta/p:Forbidden channel"
+          "error"       =>"405:invalid:Invalid channel"
         }
       ]
     end
     
     it "routes single messages to appropriate handlers" do
       server.should_receive(:handshake).with(handshake, false)
-      server.process(handshake, false) {}
+      server.process(handshake, false)
     end
     
     it "routes a list of messages to appropriate handlers" do
@@ -66,41 +63,6 @@ describe Faye::Server do
       server.process([handshake, connect, disconnect, subscribe, unsubscribe, publish], false)
     end
     
-    describe "publishing a message" do
-      it "tells the engine to publish the message" do
-        engine.should_receive(:publish).with(publish)
-        server.process(publish, false) {}
-      end
-      
-      it "returns no response" do
-        engine.stub(:publish)
-        server.process(publish, false) { |r| r.should == [] }
-      end
-      
-      describe "with an error" do
-        before { publish["error"] = "invalid" }
-        
-        it "does not tell the engine to publish the message" do
-          engine.should_not_receive(:publish)
-          server.process(publish, false) {}
-        end
-        
-        it "returns no response" do
-          engine.stub(:publish)
-          server.process(publish, false) { |r| r.should == [] }
-        end
-      end
-
-      describe "to an invalid channel" do
-        before { publish["channel"] = "/invalid/*" }
-
-        it "does not tell the engine to publish the message" do
-          engine.should_not_receive(:publish)
-          server.process(publish, false) {}
-        end
-      end
-    end
-    
     describe "handshaking" do
       before do
         response = {"channel" => "/meta/handshake", "successful" => true}