sockjs 0.2.1

data/lib/sockjs/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module SockJS
+  # SockJS protocol version.
+  PROTOCOL_VERSION = [0, 2, 1]
+
+  PROTOCOL_VERSION_STRING = PROTOCOL_VERSION.join(".")
+
+  # Patch version of the gem.
+  PATCH_VERSION = []
+
+  GEM_VERSION = (PROTOCOL_VERSION + PATCH_VERSION).join(".")
+end

data/spec/sockjs/protocol_spec.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env bundle exec rspec
+# encoding: utf-8
+
+require "spec_helper"
+require "sockjs/protocol"
+
+describe SockJS::Protocol do
+  it "OpeningFrame should be 'o'" do
+    described_class::OpeningFrame.instance.to_s.should eql("o")
+  end
+
+  it "HeartbeatFrame should be 'h'" do
+    described_class::HeartbeatFrame.instance.to_s.should eql("h")
+  end
+
+  describe "ArrayFrame" do
+    it "should take only an array as the first argument" do
+      expect {
+        SockJS::Protocol::ArrayFrame.new(Hash.new)
+      }.to raise_error(TypeError)
+    end
+
+    it "should return a valid array frame" do
+      SockJS::Protocol::ArrayFrame.new([1, 2, 3]).to_s.should eql("a[1,2,3]")
+      SockJS::Protocol::ArrayFrame.new(["tests"]).to_s.should eql('a["tests"]')
+    end
+  end
+
+  describe "ClosingFrame" do
+    it "should take only integer as the first argument" do
+      expect {
+        SockJS::Protocol::ClosingFrame.new("2010", "message")
+      }.to raise_error(TypeError)
+    end
+
+    it "should take only string as the second argument" do
+      expect {
+        SockJS::Protocol::ClosingFrame.new(2010, :message)
+      }.to raise_error(TypeError)
+    end
+
+    it "should return a valid closing frame" do
+      expect {
+        frame = SockJS::Protocol::ClosingFrame.new(2010, "message")
+        frame.to_s.should eql('c[2010,"message"]')
+      }.not_to raise_error
+    end
+  end
+end

data/spec/sockjs/session_spec.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env bundle exec rspec
+# encoding: utf-8
+
+require "spec_helper"
+
+require "sockjs"
+require "sockjs/session"
+require "sockjs/transports/xhr"
+
+#Comment:
+#These specs came to me way to interested in the internals of Session
+#Policy has got to be that any spec that fails because e.g. it wants to know
+#what state Session is in is a fail.  Okay to spec that Session should be able
+#to respond to message X after Y, though.
+
+describe SockJS::Session do
+  around :each do |example|
+    EM.run do
+      example.run
+      EM.stop
+    end
+  end
+
+  let :connection do
+    SockJS::Connection.new {}
+  end
+
+  let :transport do
+    xprt = SockJS::Transports::XHRPost.new(connection, Hash.new)
+
+    def xprt.send
+    end
+
+    xprt
+  end
+
+  let :request do
+    FakeRequest.new.tap do|req|
+      req.data = ""
+    end
+  end
+
+  let :response do
+    transport.response_class.new(request, 200)
+  end
+
+  let :session do
+    sess = described_class.new({:open => []})
+    sess
+  end
+end

data/spec/sockjs/transport_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+require "sockjs"
+require "sockjs/transport"
+
+describe SockJS::Transport do
+  describe "CONTENT_TYPES" do
+    [:plain, :html, :javascript, :event_stream].each do |type|
+      it "should define #{type}" do
+        described_class::CONTENT_TYPES[type].should_not be_nil
+      end
+    end
+  end
+
+  subject do
+    described_class.new(Object.new, Hash.new)
+  end
+
+  describe "#disabled?", :pending => "valid?" do
+    it "should be false if the current class isn't in disabled_transports" do
+      subject.should_not be_disabled
+    end
+
+    it "should be false if the current class is in disabled_transports" do
+      subject.options[:disabled_transports] = [subject.class]
+      subject.should be_disabled
+    end
+  end
+
+  describe "#session_class" do
+    it "should be a valid class" do
+      subject.session_class.should be_kind_of(Class)
+    end
+  end
+
+  describe "#response_class" do
+    it "should be a valid class" do
+      subject.response_class.should be_kind_of(Class)
+    end
+  end
+
+  let :session do
+    mock("Session")
+  end
+
+  describe "#format_frame(payload)" do
+    it "should fail if payload is nil" do
+      expect do
+        subject.format_frame(session, nil)
+      end.to raise_error(TypeError)
+    end
+
+    it "should return payload followed by \\n otherwise" do
+      subject.format_frame(session, "o").should eql("o\n")
+    end
+  end
+
+  describe "#response(request, status)" do
+    # TODO
+  end
+
+  describe "#respond(request, status, options = Hash.new, &block)" do
+    # TODO
+  end
+
+  describe "#error(http_status, content_type, body)" do
+    # TODO
+  end
+
+  describe "#get_session(request, response, preamble = nil)" do
+    # TODO
+  end
+end

data/spec/sockjs/transports/eventsource_spec.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env bundle exec rspec
+# encoding: utf-8
+
+require "spec_helper"
+
+require "sockjs"
+require "sockjs/transports/eventsource"
+
+describe SockJS::Transports::EventSource, :type => :transport, :em => true do
+  transport_handler_eql "/eventsource", "GET"
+
+  describe "#handle(request)" do
+    let(:request) do
+      @request ||= begin
+        request = FakeRequest.new
+        request.path_info = "/echo/a/b/eventsource"
+        request
+      end
+    end
+
+    let(:response) do
+      def transport.try_timer_if_valid(*)
+      end
+
+      transport.handle(request)
+    end
+
+    it "should respond with HTTP 200" do
+      response.status.should eql(200)
+    end
+
+    it "should respond with event stream MIME type" do
+      response.headers["Content-Type"].should match("text/event-stream")
+    end
+
+    it "should disable caching" do
+      response.headers["Cache-Control"].should eql("no-store, no-cache, must-revalidate, max-age=0")
+    end
+
+    it "should write two empty lines for Opera" do
+      response # Run the handler.
+
+      pending 'We do split("\r\n"), remember?' do
+        response.chunks[0].should eql("")
+      end
+    end
+  end
+
+  describe "#format_frame(payload)" do
+    it "should format payload"
+  end
+
+  describe "#escape_selected(*args)" do
+    it "should escape given payload"
+  end
+end

data/spec/sockjs/transports/htmlfile_spec.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env bundle exec rspec
+# encoding: utf-8
+
+require "spec_helper"
+
+require "sockjs"
+require "sockjs/transports/htmlfile"
+
+describe SockJS::Transports::HTMLFile, :em => true, :type => :transport do
+  transport_handler_eql "/htmlfile", "GET"
+
+  describe "#handle(request)" do
+    let(:request) do
+      FakeRequest.new
+    end
+
+    let(:response) do
+      def transport.try_timer_if_valid(*)
+      end
+
+      transport.handle(request)
+    end
+
+    context "with callback specified" do
+      let(:request) do
+        @request ||= FakeRequest.new.tap do |request|
+          request.query_string = {"c" => "clbk"}
+          request.path_info = '/a/b/htmlfile'
+          request.session_key = 'b'
+        end
+      end
+
+      it "should respond with HTTP 200" do
+        response.status.should eql(200)
+      end
+
+      it "should respond with HTML MIME type" do
+        response.headers["Content-Type"].should match("text/html")
+      end
+
+      it "should disable caching" do
+        response.headers["Cache-Control"].should eql("no-store, no-cache, must-revalidate, max-age=0")
+      end
+
+      it "should return HTML wrapper in the body" do
+        response.chunks.find{|chunk| chunk =~ (/document.domain = document.domain/)}.should_not be_nil
+      end
+
+      it "should have at least 1024 bytes"
+      it "should replace {{ callback }} with the actual callback name"
+    end
+
+    context "without callback specified" do
+      it "should respond with HTTP 500" do
+        response.status.should eql(500)
+      end
+
+      it "should respond with HTML MIME type" do
+        response.headers["Content-Type"].should match("text/html")
+      end
+
+      it "should return error message in the body" do
+        response # Run the handler.
+        response.chunks.last.should match(/"callback" parameter required/)
+      end
+    end
+  end
+
+  describe "#format_frame(payload)" do
+    it "should format payload"
+  end
+end

data/spec/sockjs/transports/iframe_spec.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require "spec_helper"
+require "sockjs"
+require "sockjs/transports/iframe"
+
+describe SockJS::Transports::IFrame, :type => :transport do
+  describe "#handle(request)" do
+    let(:transport) do
+      described_class.new(connection, sockjs_url: "http://sock.js/sock.js")
+    end
+
+    let(:response) do
+      transport.handle(request)
+    end
+
+    context "If-None-Match header matches ETag of current body" do
+      let(:request) do
+        @request ||= FakeRequest.new.tap do |request|
+          etag = '"af0ca7deb5298aeb946c4f7b96d1501b"'
+          request.if_none_match = etag
+          request.path_info = "/iframe.html"
+        end
+      end
+
+      it "should respond with HTTP 304" do
+        response.status.should eql(304)
+      end
+    end
+
+    context "If-None-Match header doesn't match ETag of current body" do
+      let(:request) do
+        @request ||= FakeRequest.new.tap do |request|
+          request.path_info = "/iframe.html"
+        end
+      end
+
+      it "should respond with HTTP 200" do
+        response.status.should eql(200)
+      end
+
+      it "should respond with HTML MIME type" do
+        response.headers["Content-Type"].should match("text/html")
+      end
+
+      it "should set ETag header"
+
+      it "should set cache control to be valid for the next year" do
+        time = Time.now + 31536000
+
+        response.headers["Cache-Control"].should eql("public, max-age=31536000")
+        response.headers["Expires"].should eql(time.gmtime.to_s)
+        response.headers["Access-Control-Max-Age"].should eql("1000001")
+      end
+
+      it "should return HTML wrapper in the body" do
+        response # Run the handler.
+        response.chunks.last.should match(/document.domain = document.domain/)
+      end
+
+      it "should set sockjs_url" do
+        response # Run the handler.
+        response.chunks.last.should match(transport.options[:sockjs_url])
+      end
+    end
+  end
+end

data/spec/sockjs/transports/jsonp_spec.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env bundle exec rspec
+# encoding: utf-8
+
+require "spec_helper"
+
+require "sockjs"
+require "sockjs/transports/jsonp"
+
+describe "JSONP", :em => true, :type => :transport do
+  let(:open_request) do
+    FakeRequest.new.tap do |request|
+      request.path_info = "/jsonp"
+      request.query_string = {"c" => "clbk"}
+      request.data = "ok"
+      request.session_key = "b"
+    end
+  end
+
+  describe SockJS::Transports::JSONP do
+    transport_handler_eql "/jsonp", "GET"
+
+    describe "#handle(request)" do
+      let(:request) do
+        FakeRequest.new.tap do |request|
+          request.path_info = "/echo/a/b/jsonp"
+        end
+      end
+
+      context "with callback specified" do
+        let(:request) do
+          FakeRequest.new.tap do |request|
+            request.path_info = "/jsonp"
+            request.query_string = {"c" => "clbk"}
+            request.session_key = "b"
+          end
+        end
+
+        context "with a session" do
+          let(:prior_transport) do
+            described_class.new(connection, {})
+          end
+
+          it "should respond with HTTP 200" do
+            response.status.should eql(200)
+          end
+
+          it "should respond with plain text MIME type" do
+            response.headers["Content-Type"].should match("application/javascript")
+          end
+
+          it "should respond with a body"
+        end
+
+        context "without any session" do
+          it "should respond with HTTP 200" do
+            response.status.should eql(200)
+          end
+
+          it "should respond with javascript MIME type" do
+            response.headers["Content-Type"].should match("application/javascript")
+          end
+
+          it "should set access control" do
+            response.headers["Access-Control-Allow-Origin"].should eql(request.origin)
+            response.headers["Access-Control-Allow-Credentials"].should eql("true")
+          end
+
+          it "should disable caching" do
+            response.headers["Cache-Control"].should eql("no-store, no-cache, must-revalidate, max-age=0")
+          end
+
+          it "should open a new session"
+        end
+      end
+
+      context "without callback specified" do
+        it "should respond with HTTP 500" do
+          response.status.should eql(500)
+        end
+
+        it "should respond with HTML MIME type" do
+          response.headers["Content-Type"].should match("text/html")
+        end
+
+        it "should return error message in the body" do
+          response.chunks.last.should match(/"callback" parameter required/)
+        end
+      end
+    end
+
+    describe "#format_frame(payload)" do
+      it "should format payload"
+    end
+  end
+
+  describe SockJS::Transports::JSONPSend do
+    transport_handler_eql "/jsonp_send", "POST"
+
+    describe "#handle(request)" do
+      let(:request) do
+        FakeRequest.new.tap do |request|
+          request.path_info = "/a/_/jsonp_send"
+        end
+      end
+
+      context "with valid data" do
+        context "with application/x-www-form-urlencoded" do
+          # TODO: test with invalid data like d=sth, we should get Broken encoding.
+          context "with a valid session" do
+            before :each do
+              session
+            end
+
+            let(:request) do
+              FakeRequest.new.tap do |request|
+                request.path_info = "/jsonp_send"
+                request.session_key = existing_session_key
+                request.content_type = "application/x-www-form-urlencoded"
+                request.data = "d=%5B%22x%22%5D"
+              end
+            end
+
+            it "should respond with HTTP 200" do
+              response.status.should eql(200)
+            end
+
+            it "should set session ID" do
+              cookie = response.headers["Set-Cookie"]
+              cookie.should match("JSESSIONID=#{request.session_id}; path=/")
+            end
+
+            it "should write 'ok' to the body stream" do
+              response # Run the handler.
+              response.chunks.last.should eql("ok")
+            end
+          end
+
+          context "without a valid session" do
+            let :session do
+            end
+
+            let(:request) do
+              FakeRequest.new.tap do |request|
+                request.path_info = "/a/_/jsonp_send"
+                request.content_type = "application/x-www-form-urlencoded"
+                request.data = "d=sth"
+              end
+            end
+
+            it "should respond with HTTP 404" do
+              SockJS::debug!
+              response.status.should eql(404)
+            end
+
+            it "should respond with plain text MIME type" do
+              response.headers["Content-Type"].should match("text/plain")
+            end
+
+            it "should return error message in the body" do
+              response # Run the handler.
+              response.chunks.last.should match(/Session is not open\!/)
+            end
+          end
+        end
+
+        context "with any other MIME type" do
+          context "with a valid session" do
+            before :each do
+              session
+            end
+
+            let(:request) do
+              FakeRequest.new.tap do |request|
+                request.path_info = "/jsonp_send"
+                request.data = '["data"]'
+                request.session_key = existing_session_key
+              end
+            end
+
+            it "should respond with HTTP 200" do
+              response.status.should eql(200)
+            end
+
+            it "should set session ID" do
+              cookie = response.headers["Set-Cookie"]
+              cookie.should match("JSESSIONID=#{request.session_id}; path=/")
+            end
+
+            it "should write 'ok' to the body stream" do
+              response # Run the handler.
+              response.chunks.last.should eql("ok")
+            end
+          end
+
+          context "without a valid session" do
+            let :session do
+            end
+
+            let(:request) do
+              FakeRequest.new.tap do |request|
+                request.path_info = "/a/_/jsonp_send"
+                request.data = "data"
+              end
+            end
+
+            it "should respond with HTTP 404" do
+              response.status.should eql(404)
+            end
+
+            it "should respond with plain text MIME type" do
+              response.headers["Content-Type"].should match("text/plain")
+            end
+
+            it "should return error message in the body" do
+              response.chunks.last.should match(/Session is not open\!/)
+            end
+          end
+        end
+      end
+
+      [nil, "", "d=", "f=test"].each do |data|
+        context "with data = #{data.inspect}" do
+          before :each do
+            session
+          end
+
+          let(:request) do
+            FakeRequest.new.tap do |request|
+              request.path_info = "/jsonp_send"
+              request.session_key = "b"
+              request.content_type = "application/x-www-form-urlencoded"
+              request.data = data
+            end
+          end
+
+          it "should respond with HTTP 500" do
+            response.status.should eql(500)
+          end
+
+          it "should respond with HTML MIME type" do
+            response.headers["Content-Type"].should match("text/html")
+          end
+
+          it "should return error message in the body" do
+            response # Run the handler.
+            response.chunks.last.should match(/Payload expected./)
+          end
+        end
+      end
+    end
+  end
+end