faye 0.5.5 → 0.6.0

data/spec/ruby/server/connect_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+
+describe "server connect" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+  
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  
+  describe :connect do
+    let(:client_id) { "fakeclientid" }
+    let(:message) {{"channel" => "/meta/connect",
+                    "clientId" => "fakeclientid",
+                    "connectionType" => "long-polling"
+                  }}
+    
+    describe "with valid paramters" do
+      before do
+        message["advice"] = {"timeout" => 60}
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      
+      it "connects to the engine to wait for new messages" do
+        engine.should_receive(:connect).with(client_id, {"timeout" => 60})
+        server.connect(message) {}
+      end
+      
+      it "returns a successful response and any queued messages" do
+        engine.stub(:connect).and_yield([{"channel" => "/x", "data" => "hello"}])
+        server.connect(message) do |response|
+          response.should == [
+            { "channel"    => "/meta/connect",
+              "successful" => true,
+              "clientId"   => client_id
+            }, {
+              "channel" => "/x",
+              "data"    => "hello"
+            }
+          ]
+        end
+      end
+      
+      describe "with a message id" do
+        before { message["id"] = "foo" }
+        
+        it "returns the same id" do
+          engine.stub(:connect)
+          server.connect(message) do |response|
+            response.should == {
+              "channel"    => "/meta/connect",
+              "successful" => true,
+              "clientId"   => client_id,
+              "id"         => "foo"
+            }
+          end
+        end
+      end
+    end
+    
+    describe "with an unknown client" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield false
+      end
+      
+      it "does not connect to the engine" do
+        engine.should_not_receive(:connect)
+        server.connect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.connect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/connect",
+            "successful" => false,
+            "error"      => "401:fakeclientid:Unknown client"
+          }
+        end
+      end
+    end
+    
+    describe "missing clientId" do
+      before do
+        message.delete("clientId")
+        engine.should_receive(:client_exists).with(nil).and_yield false
+      end
+      
+      it "does not connect to the engine" do
+        engine.should_not_receive(:connect)
+        server.connect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.connect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/connect",
+            "successful" => false,
+            "error"      => "402:clientId:Missing required parameter"
+          }
+        end
+      end
+    end
+    
+    describe "missing connectionType" do
+      before do
+        message.delete("connectionType")
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      
+      it "does not connect to the engine" do
+        engine.should_not_receive(:connect)
+        server.connect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.connect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/connect",
+            "successful" => false,
+            "error"      => "402:connectionType:Missing required parameter"
+          }
+        end
+      end
+    end
+    
+    describe "with an unknown connectionType" do
+      before do
+        message["connectionType"] = "flash"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      
+      it "does not connect to the engine" do
+        engine.should_not_receive(:connect)
+        server.connect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.connect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/connect",
+            "successful" => false,
+            "error"      => "301:flash:Connection types not supported"
+          }
+        end
+      end
+    end
+    
+    describe "with an error" do
+      before do
+        message["error"] = "invalid"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      
+      it "does not connect to the engine" do
+        engine.should_not_receive(:connect)
+        server.connect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.connect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/connect",
+            "successful" => false,
+            "error"      => "invalid"
+          }
+        end
+      end
+    end
+  end
+end

data/spec/ruby/server/disconnect_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe "server disconnect" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+  
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  
+  describe :disconnect do
+    let(:client_id) { "fakeclientid" }
+    let(:message) {{"channel" => "/meta/disconnect",
+                    "clientId" => "fakeclientid"
+                  }}
+    
+    describe "with valid parameters" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      
+      it "destroys the client" do
+        engine.should_receive(:destroy_client).with(client_id)
+        server.disconnect(message) {}
+      end
+      
+      it "returns a successful response" do
+        engine.stub(:destroy_client)
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => true,
+            "clientId"   => client_id
+          }
+        end
+      end
+      
+      describe "with a message id" do
+        before { message["id"] = "foo" }
+        
+        it "returns the same id" do
+          engine.stub(:destroy_client)
+          server.disconnect(message) do |response|
+            response.should == {
+              "channel"    => "/meta/disconnect",
+              "successful" => true,
+              "clientId"   => client_id,
+              "id"         => "foo"
+            }
+          end
+        end
+      end
+    end
+    
+    describe "with an unknown client" do
+      before do
+        engine.should_receive(:client_exists).with(client_id).and_yield false
+      end
+      
+      it "does not destroy the client" do
+        engine.should_not_receive(:destroy_client)
+        server.disconnect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => false,
+            "error"      => "401:fakeclientid:Unknown client"
+          }
+        end
+      end
+    end
+    
+    describe "missing clientId" do
+      before do
+        message.delete("clientId")
+        engine.should_receive(:client_exists).with(nil).and_yield false
+      end
+      
+      it "does not destroy the client" do
+        engine.should_not_receive(:destroy_client)
+        server.disconnect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => false,
+            "error"      => "402:clientId:Missing required parameter"
+          }
+        end
+      end
+    end
+    
+    describe "with an error" do
+      before do
+        message["error"] = "invalid"
+        engine.should_receive(:client_exists).with(client_id).and_yield true
+      end
+      
+      it "does not destroy the client" do
+        engine.should_not_receive(:destroy_client)
+        server.disconnect(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.disconnect(message) do |response|
+          response.should == {
+            "channel"    => "/meta/disconnect",
+            "successful" => false,
+            "error"      => "invalid"
+          }
+        end
+      end
+    end
+  end
+end

data/spec/ruby/server/extensions_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe "server extensions" do
+  let(:engine) do
+    engine = mock "engine"
+    engine.stub(:interval).and_return(0)
+    engine.stub(:timeout).and_return(60)
+    engine
+  end
+  
+  let(:server)  { Faye::Server.new }
+  let(:message) { {"channel" => "/foo", "data" => "hello"} }
+  let(:advice)  { {"reconnect"=>"retry", "interval"=>0, "timeout"=>60000} }
+  
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  
+  describe "with an incoming extension installed" do
+    before do
+      extension = Class.new do
+        def incoming(message, callback)
+          message["ext"] = {"auth" => "password"}
+          callback.call(message)
+        end
+      end
+      server.add_extension(extension.new)
+    end
+    
+    it "passes incoming messages through the extension" do
+      engine.should_receive(:publish).with({"channel" => "/foo", "data" => "hello", "ext" => {"auth" => "password"}})
+      server.process(message, false) {}
+    end
+    
+    it "does not pass outgoing messages through the extension" do
+      server.stub(:handshake).and_yield(message)
+      engine.stub(:publish)
+      response = nil
+      server.process({"channel" => "/meta/handshake"}, false) { |r| response = r }
+      response.should == [{"channel" => "/foo", "data" => "hello", "advice" => advice}]
+    end
+  end
+  
+  describe "with an outgoing extension installed" do
+    before do
+      extension = Class.new do
+        def outgoing(message, callback)
+          message["ext"] = {"auth" => "password"}
+          callback.call(message)
+        end
+      end
+      server.add_extension(extension.new)
+    end
+    
+    it "does not pass incoming messages through the extension" do
+      engine.should_receive(:publish).with({"channel" => "/foo", "data" => "hello"})
+      server.process(message, false) {}
+    end
+    
+    it "passes outgoing messages through the extension" do
+      server.stub(:handshake).and_yield(message)
+      engine.stub(:publish)
+      response = nil
+      server.process({"channel" => "/meta/handshake"}, false) { |r| response = r }
+      response.should == [{"channel" => "/foo", "data" => "hello", "advice" => advice, "ext" => {"auth" => "password"}}]
+    end
+  end
+end
+

data/spec/ruby/server/handshake_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+
+describe "server handshake" do
+  let(:engine) { mock "engine" }
+  let(:server) { Faye::Server.new }
+  
+  before do
+    Faye::Engine.stub(:get).and_return engine
+  end
+  
+  describe :handshake do
+    let(:message) {{"channel" => "/meta/handshake",
+                    "version" => "1.0",
+                    "supportedConnectionTypes" => ["long-polling"]
+                  }}
+    
+    describe "with valid parameters" do
+      it "creates a client" do
+        engine.should_receive(:create_client)
+        server.handshake(message) {}
+      end
+      
+      it "returns a successful response" do
+        engine.stub(:create_client).and_yield "clientid"
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => true,
+            "version"    => "1.0",
+            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket"],
+            "clientId"   => "clientid"
+          }
+        end
+      end
+      
+      describe "with a message id" do
+        before { message["id"] = "foo" }
+        
+        it "returns the same id" do
+          engine.stub(:create_client).and_yield "clientid"
+          server.handshake(message) do |response|
+            response.should == {
+              "channel"    => "/meta/handshake",
+              "successful" => true,
+              "version"    => "1.0",
+              "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket"],
+              "clientId"   => "clientid",
+              "id"         => "foo"
+            }
+          end
+        end
+      end
+    end
+    
+    describe "missing version" do
+      before { message.delete "version" }
+      
+      it "does not create a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "402:version:Missing required parameter",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket"]
+          }
+        end
+      end
+    end
+    
+    describe "missing supportedConnectionTypes" do
+      before { message.delete "supportedConnectionTypes" }
+      
+      it "does not create a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "402:supportedConnectionTypes:Missing required parameter",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket"]
+          }
+        end
+      end
+      
+      it "returns a successful response for local clients" do
+        engine.stub(:create_client).and_yield "clientid"
+        server.handshake(message, true) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => true,
+            "version"    => "1.0",
+            "clientId"   => "clientid"
+          }
+        end
+      end
+    end
+    
+    describe "with no matching supportedConnectionTypes" do
+      before { message["supportedConnectionTypes"] = ["iframe", "flash"] }
+      
+      it "does not create a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "301:iframe,flash:Connection types not supported",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket"]
+          }
+        end
+      end
+    end
+    
+    describe "with an error" do
+      before { message["error"] = "invalid" }
+      
+      it "does not createa a client" do
+        engine.should_not_receive(:create_client)
+        server.handshake(message) {}
+      end
+      
+      it "returns an unsuccessful response" do
+        server.handshake(message) do |response|
+          response.should == {
+            "channel"    => "/meta/handshake",
+            "successful" => false,
+            "error"      => "invalid",
+            "version"    => "1.0",
+            "supportedConnectionTypes" => ["long-polling","cross-origin-long-polling","callback-polling","websocket"]
+          }
+        end
+      end
+    end
+  end  
+end