faye 0.8.11 → 1.0.0

data/spec/ruby/grammar_spec.rb

@@ -1,68 +0,0 @@
-require "spec_helper"
-
-describe Faye::Grammar do
-  describe :CHANNEL_NAME do
-    it "matches valid channel names" do
-      Faye::Grammar::CHANNEL_NAME.should =~ "/fo_o/$@()bar"
-    end
-
-    it "does not match channel patterns" do
-      Faye::Grammar::CHANNEL_NAME.should_not =~ "/foo/**"
-    end
-
-    it "does not match invalid channel names" do
-      Faye::Grammar::CHANNEL_NAME.should_not =~ "foo/$@()bar"
-      Faye::Grammar::CHANNEL_NAME.should_not =~ "/foo/$@()bar/"
-      Faye::Grammar::CHANNEL_NAME.should_not =~ "/fo o/$@()bar"
-    end
-  end
-
-  describe :CHANNEL_PATTERN do
-    it "does not match channel names" do
-      Faye::Grammar::CHANNEL_PATTERN.should_not =~ "/fo_o/$@()bar"
-    end
-
-    it "matches valid channel patterns" do
-      Faye::Grammar::CHANNEL_PATTERN.should =~ "/foo/**"
-      Faye::Grammar::CHANNEL_PATTERN.should =~ "/foo/*"
-    end
-
-    it "does not match invalid channel patterns" do
-      Faye::Grammar::CHANNEL_PATTERN.should_not =~ "/foo/**/*"
-    end
-  end
-
-  describe :ERROR do
-    it "matches an error with an argument" do
-      Faye::Grammar::ERROR.should =~ "402:xj3sjdsjdsjad:Unknown Client ID"
-    end
-
-    it "matches an error with many arguments" do
-      Faye::Grammar::ERROR.should =~ "403:xj3sjdsjdsjad,/foo/bar:Subscription denied"
-    end
-
-    it "matches an error with no arguments" do
-      Faye::Grammar::ERROR.should =~ "402::Unknown Client ID"
-    end
-
-    it "does not match an error with no code" do
-      Faye::Grammar::ERROR.should_not =~ ":xj3sjdsjdsjad:Unknown Client ID"
-    end
-
-    it "does not match an error with an invalid code" do
-      Faye::Grammar::ERROR.should_not =~ "40:xj3sjdsjdsjad:Unknown Client ID"
-    end
-  end
-
-  describe :VERSION do
-    it "matches a version number" do
-      Faye::Grammar::VERSION.should =~ "9"
-      Faye::Grammar::VERSION.should =~ "9.0.a-delta1"
-    end
-
-    it "does not match invalid version numbers" do
-      Faye::Grammar::VERSION.should_not =~ "9.0.a-delta1."
-      Faye::Grammar::VERSION.should_not =~ ""
-    end
-  end
-end

data/spec/ruby/publisher_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-
-describe Faye::Publisher do
-  let(:publisher) { Object.new.extend(Faye::Publisher) }
-
-  describe "with subscribers that remove themselves" do
-    before do
-      @called_a = false
-      @called_b = false
-
-      handler = lambda do
-        @called_a = true
-        publisher.unbind(:event, &handler)
-      end
-
-      publisher.bind(:event, &handler)
-      publisher.bind(:event) { @called_b = true }
-    end
-
-    it "successfully calls all the callbacks" do
-      publisher.trigger(:event)
-      @called_a.should == true
-      @called_b.should == true
-    end
-  end
-end
-

data/spec/ruby/rack_adapter_spec.rb

@@ -1,241 +0,0 @@
-require "spec_helper"
-require "thin_proxy"
-
-describe Faye::RackAdapter do
-  include Rack::Test::Methods
-  let(:adapter) { Faye::RackAdapter.new(options) }
-  let(:app)     { ThinProxy.new(adapter) }
-  let(:options) { {:mount => "/bayeux", :timeout => 30} }
-  let(:server)  { mock "server" }
-
-  after { app.stop }
-
-  let(:content_type)          { last_response["Content-Type"] }
-  let(:content_length)        { last_response["Content-Length"] }
-  let(:cache_control)         { last_response["Cache-Control"] }
-  let(:access_control_origin) { last_response["Access-Control-Allow-Origin"] }
-  let(:json)                  { Yajl::Parser.parse(body) }
-  let(:body)                  { last_response.body }
-  let(:status)                { last_response.status.to_i }
-
-  before do
-    Faye::Server.should_receive(:new).with(options).and_return server
-    adapter.stub(:get_client).and_return mock("client")
-  end
-
-  describe "POST requests" do
-    describe "with cross-origin access control" do
-      shared_examples_for "cross-origin request" do
-        before do
-          header "Origin", "http://example.com"
-        end
-
-        it "returns a matching cross-origin access control header" do
-          server.stub(:process).and_yield []
-          post "/bayeux", :message => '[]'
-          access_control_origin.should == "http://example.com"
-        end
-
-        it "forwards the message param onto the server" do
-          server.should_receive(:process).with({"channel" => "/plain"}, false).and_yield []
-          post "/bayeux", "message=%7B%22channel%22%3A%22%2Fplain%22%7D"
-        end
-
-        it "returns the server's response as JSON" do
-          server.stub(:process).and_yield ["channel" => "/meta/handshake"]
-          post "/bayeux", "message=%5B%5D"
-          status.should == 200
-          content_type.should == "application/json; charset=utf-8"
-          content_length.should == "31"
-          json.should == ["channel" => "/meta/handshake"]
-        end
-
-        it "returns a 400 response if malformed JSON is given" do
-          server.should_not_receive(:process)
-          post "/bayeux", "message=%7B%5B"
-          status.should == 400
-          content_type.should == "text/plain; charset=utf-8"
-        end
-
-        it "returns a 404 if the path is not matched" do
-          server.should_not_receive(:process)
-          post "/blaf", 'message=%5B%5D'
-          status.should == 404
-          content_type.should == "text/plain; charset=utf-8"
-        end
-      end
-
-      describe "with text/plain" do
-        before { header "Content-Type", "text/plain" }
-        it_should_behave_like "cross-origin request"
-      end
-
-      describe "with application/xml" do
-        before { header "Content-Type", "application/xml" }
-        it_should_behave_like "cross-origin request"
-      end
-    end
-
-    describe "with application/json" do
-      before do
-        header "Content-Type", "application/json"
-      end
-
-      it "does not return an access control header" do
-        server.stub(:process).and_yield []
-        post "/bayeux", :message => '[]'
-        access_control_origin.should be_nil
-      end
-
-      it "forwards the POST body onto the server" do
-        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
-        post "/bayeux", '{"channel":"/foo"}'
-      end
-
-      it "returns the server's response as JSON" do
-        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
-        post "/bayeux", '[]'
-        status.should == 200
-        content_type.should == "application/json; charset=utf-8"
-          content_length.should == "31"
-        json.should == ["channel" => "/meta/handshake"]
-      end
-
-      it "returns a 400 response if malformed JSON is given" do
-        server.should_not_receive(:process)
-        post "/bayeux", "[}"
-        status.should == 400
-        content_type.should == "text/plain; charset=utf-8"
-      end
-
-      it "returns a 404 if the path is not matched" do
-        server.should_not_receive(:process)
-        post "/blaf", "[]"
-        status.should == 404
-        content_type.should == "text/plain; charset=utf-8"
-      end
-    end
-
-    describe "with no content type" do
-      it "forwards the message param onto the server" do
-        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
-        post "/bayeux", :message => '{"channel":"/foo"}'
-      end
-
-      it "returns the server's response as JSON" do
-        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
-        post "/bayeux", :message => '[]'
-        status.should == 200
-        content_type.should == "application/json; charset=utf-8"
-        content_length.should == "31"
-        json.should == ["channel" => "/meta/handshake"]
-      end
-
-      it "returns a 400 response if malformed JSON is given" do
-        server.should_not_receive(:process)
-        post "/bayeux", :message => "[}"
-        status.should == 400
-        content_type.should == "text/plain; charset=utf-8"
-      end
-
-      it "returns a 404 if the path is not matched" do
-        server.should_not_receive(:process)
-        post "/blaf", :message => "[]"
-        status.should == 404
-        content_type.should == "text/plain; charset=utf-8"
-      end
-    end
-  end
-
-  describe "GET requests" do
-    let(:params) {{:message => '{"channel":"/foo"}', :jsonp => "callback"}}
-
-    describe "with valid params" do
-      before do
-        server.should_receive(:flush_connection).with("channel" => "/foo")
-      end
-
-      it "forwards the message param onto the server" do
-        server.should_receive(:process).with({"channel" => "/foo"}, false).and_yield []
-        get "/bayeux", params
-      end
-
-      it "returns the server's response as JavaScript" do
-        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
-        get "/bayeux", params
-        status.should == 200
-        content_type.should == "text/javascript; charset=utf-8"
-        content_length.should == "46"
-        body.should == '/**/callback([{"channel":"/meta/handshake"}]);'
-      end
-
-      it "does not let the client cache the response" do
-        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
-        get "/bayeux", params
-        cache_control.should == "no-cache, no-store"
-      end
-    end
-
-    describe "with an unknown path" do
-      it "returns a 404" do
-        server.should_not_receive(:process)
-        get "/blah", params
-        status.should == 404
-        content_type.should == "text/plain; charset=utf-8"
-      end
-    end
-
-    describe "missing jsonp" do
-      before do
-        params.delete(:jsonp)
-        server.should_receive(:flush_connection)
-      end
-
-      it "returns the server's response using the default callback" do
-        server.stub(:process).and_yield ["channel" => "/meta/handshake"]
-        get "/bayeux", params
-        status.should == 200
-        content_type.should == "text/javascript; charset=utf-8"
-        content_length.should == "51"
-        body.should == '/**/jsonpcallback([{"channel":"/meta/handshake"}]);'
-      end
-    end
-
-    shared_examples_for "bad GET request" do
-      it "does not call the server" do
-        server.should_not_receive(:process)
-        get "/bayeux", params
-      end
-
-      it "returns a 400 response" do
-        get "/bayeux", params
-        status.should == 400
-        content_type.should == "text/plain; charset=utf-8"
-      end
-    end
-
-    describe "with malformed JSON" do
-      before { params[:message] = "[}" }
-      it_should_behave_like "bad GET request"
-    end
-
-    describe "with a callback that's not a JS identifier" do
-      before { params[:jsonp] = "42" }
-      it_should_behave_like "bad GET request"
-    end
-
-    describe "missing message" do
-      before { params.delete(:message) }
-      it_should_behave_like "bad GET request"
-    end
-
-    describe "for the client script" do
-      it "returns the client script" do
-        get "/bayeux.js"
-        status.should == 200
-        content_type.should == "text/javascript; charset=utf-8"
-        body.should =~ /function\(\)\{/
-      end
-    end
-  end
-end

data/spec/ruby/server/connect_spec.rb

@@ -1,170 +0,0 @@
-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