websocket 1.0.0

data/spec/handshake/client_04_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Client draft 4 handshake' do
+  let(:handshake) { WebSocket::Handshake::Client.new({ :uri => 'ws://example.com/demo', :origin => 'http://example.com', :version => version }.merge(@request_params || {})) }
+
+  let(:version) { 4 }
+  let(:client_request) { client_handshake_04({ :key => handshake.send(:key), :version => version }.merge(@request_params || {})) }
+  let(:server_response) { server_handshake_04({ :accept => handshake.send(:accept) }.merge(@request_params || {})) }
+
+  it_should_behave_like 'all client drafts'
+
+  it "should disallow client with invalid challenge" do
+    @request_params = { :accept => "invalid" }
+    handshake << server_response
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_accept)
+  end
+end

data/spec/handshake/client_75_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'Client draft 75 handshake' do
+  let(:handshake) { WebSocket::Handshake::Client.new({ :uri => 'ws://example.com/demo', :origin => 'http://example.com', :version => version }.merge(@request_params || {})) }
+
+  let(:version) { 75 }
+  let(:client_request) { client_handshake_75(@request_params || {}) }
+  let(:server_response) { server_handshake_75(@request_params || {}) }
+
+  it_should_behave_like 'all client drafts'
+end

data/spec/handshake/client_76_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Client draft 76 handshake' do
+  let(:handshake) { WebSocket::Handshake::Client.new({ :uri => 'ws://example.com/demo', :origin => 'http://example.com', :version => version }.merge(@request_params || {})) }
+
+  let(:version) { 76 }
+  let(:client_request) { client_handshake_76({ :key1 => handshake.key1, :key2 => handshake.key2, :key3 => handshake.key3 }.merge(@request_params || {})) }
+  let(:server_response) { server_handshake_76({ :challenge => handshake.send(:challenge) }.merge(@request_params || {})) }
+
+  it_should_behave_like 'all client drafts'
+
+  it "should disallow client with invalid challenge" do
+    @request_params = { :challenge => "invalid" }
+    handshake << server_response
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_challenge)
+  end
+end

data/spec/handshake/server_04_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Server draft 04 handshake' do
+  let(:handshake) { WebSocket::Handshake::Server.new }
+  let(:version) { 04 }
+  let(:client_request) { client_handshake_04(@request_params || {}) }
+  let(:server_response) { server_handshake_04(@request_params || {}) }
+
+  it_should_behave_like 'all server drafts'
+
+  it "should disallow request without Sec-WebSocket-Key" do
+    handshake << client_request.gsub(/^Sec-WebSocket-Key:.*\n/, '')
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_handshake_authentication)
+  end
+end

data/spec/handshake/server_75_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'Server draft 75 handshake' do
+  let(:handshake) { WebSocket::Handshake::Server.new }
+
+  let(:version) { 75 }
+  let(:client_request) { client_handshake_75(@request_params || {}) }
+  let(:server_response) { server_handshake_75(@request_params || {}) }
+
+  it_should_behave_like 'all server drafts'
+end

data/spec/handshake/server_76_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'Server draft 76 handshake' do
+  let(:handshake) { WebSocket::Handshake::Server.new }
+  let(:version) { 76 }
+  let(:client_request) { client_handshake_76(@request_params || {}) }
+  let(:server_response) { server_handshake_76(@request_params || {}) }
+
+  it_should_behave_like 'all server drafts'
+
+  it "should disallow request without spaces in key 1" do
+    @request_params = { :key1 => "4@146546xW%0l15" }
+    handshake << client_request
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_handshake_authentication)
+  end
+
+  it "should disallow request without spaces in key 2" do
+    @request_params = { :key2 => "129985Y31.P00" }
+    handshake << client_request
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_handshake_authentication)
+  end
+
+  it "should disallow request with invalid number of spaces or numbers in key 1" do
+    @request_params = { :key1 => "4 @1   46546xW%0l 1 5" }
+    handshake << client_request
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_handshake_authentication)
+  end
+
+  it "should disallow request with invalid number of spaces or numbers in key 2" do
+    @request_params = { :key2 => "12998  5 Y3 1  .P00" }
+    handshake << client_request
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_handshake_authentication)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+
+require 'websocket'
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

data/spec/support/all_client_drafts.rb

@@ -0,0 +1,77 @@
+shared_examples_for 'all client drafts' do
+  def validate_request
+    handshake.to_s.should eql(client_request)
+
+    handshake << server_response
+
+    handshake.error.should be_nil
+    handshake.should be_finished
+    handshake.should be_valid
+  end
+
+  it "should be valid" do
+    handshake << server_response
+
+    handshake.error.should be_nil
+    handshake.should be_finished
+    handshake.should be_valid
+  end
+
+  it "should return valid version" do
+    handshake.version.should eql(version)
+  end
+
+  it "should return valid host" do
+    @request_params = { :host => "www.test.cc" }
+    handshake.host.should eql('www.test.cc')
+  end
+
+  it "should return valid path" do
+    @request_params = { :path => "/custom" }
+    handshake.path.should eql('/custom')
+  end
+
+  it "should return valid query" do
+    @request_params = { :query => "aaa=bbb" }
+    handshake.query.should eql("aaa=bbb")
+  end
+
+  it "should return valid port" do
+    @request_params = { :port => 123 }
+    handshake.port.should eql(123)
+  end
+
+  it "should return valid response" do
+    validate_request
+  end
+
+  it "should allow custom path" do
+    @request_params = { :path => "/custom" }
+    validate_request
+  end
+
+  it "should allow query in path" do
+    @request_params = { :query => "test=true" }
+    validate_request
+  end
+
+  it "should allow custom port" do
+    @request_params = { :port => 123 }
+    validate_request
+  end
+
+  it "should recognize unfinished requests" do
+    handshake << server_response[0..-20]
+
+    handshake.should_not be_finished
+    handshake.should_not be_valid
+  end
+
+  it "should disallow requests with invalid request method" do
+    handshake << server_response.gsub('101', '404')
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:invalid_status_code)
+  end
+end

data/spec/support/all_server_drafts.rb

@@ -0,0 +1,86 @@
+shared_examples_for 'all server drafts' do
+  def validate_request
+    handshake << client_request
+
+    handshake.error.should be_nil
+    handshake.should be_finished
+    handshake.should be_valid
+    handshake.to_s.should eql(server_response)
+  end
+
+  it "should be valid" do
+    handshake << client_request
+
+    handshake.error.should be_nil
+    handshake.should be_finished
+    handshake.should be_valid
+  end
+
+  it "should return valid version" do
+    handshake << client_request
+
+    handshake.version.should eql(version)
+  end
+
+  it "should return valid host" do
+    @request_params = { :host => "www.test.cc" }
+    handshake << client_request
+
+    handshake.host.should eql('www.test.cc')
+  end
+
+  it "should return valid path" do
+    @request_params = { :path => "/custom" }
+    handshake << client_request
+
+    handshake.path.should eql('/custom')
+  end
+
+  it "should return valid query" do
+    @request_params = { :path => "/custom?aaa=bbb" }
+    handshake << client_request
+
+    handshake.query.should eql('aaa=bbb')
+  end
+
+  it "should return valid port" do
+    @request_params = { :port => 123 }
+    handshake << client_request
+
+    handshake.port.should eql("123")
+  end
+
+  it "should return valid response" do
+    validate_request
+  end
+
+  it "should allow custom path" do
+    @request_params = { :path => "/custom" }
+    validate_request
+  end
+
+  it "should allow query in path" do
+    @request_params = { :path => "/custom?test=true" }
+    validate_request
+  end
+
+  it "should allow custom port" do
+    @request_params = { :port => 123 }
+    validate_request
+  end
+
+  it "should recognize unfinished requests" do
+    handshake << client_request[0..-10]
+
+    handshake.should_not be_finished
+    handshake.should_not be_valid
+  end
+
+  it "should disallow requests with invalid request method" do
+    handshake << client_request.gsub('GET', 'POST')
+
+    handshake.should be_finished
+    handshake.should_not be_valid
+    handshake.error.should eql(:get_request_required)
+  end
+end

data/spec/support/handshake_requests.rb

@@ -0,0 +1,72 @@
+def client_handshake_75(args = {})
+  <<-EOF
+GET #{args[:path] || "/demo"}#{"?#{args[:query]}" if args[:query]} HTTP/1.1\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+Host: #{args[:host] || "example.com"}#{":#{args[:port]}" if args[:port]}\r
+Origin: http://example.com\r
+\r
+  EOF
+end
+
+def server_handshake_75(args = {})
+  <<-EOF
+HTTP/1.1 101 Web Socket Protocol Handshake\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+WebSocket-Origin: http://example.com\r
+WebSocket-Location: ws#{args[:secure] ? "s" : ""}://#{args[:host] || "example.com"}#{":#{args[:port]}" if args[:port]}#{args[:path] || "/demo"}\r
+\r
+  EOF
+end
+
+def client_handshake_76(args = {})
+  request = <<-EOF
+GET #{args[:path] || "/demo"}#{"?#{args[:query]}" if args[:query]} HTTP/1.1\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+Host: #{args[:host] || "example.com"}#{":#{args[:port]}" if args[:port]}\r
+Origin: http://example.com\r
+Sec-WebSocket-Key1: #{args[:key1] || "4 @1  46546xW%0l 1 5"}\r
+Sec-WebSocket-Key2: #{args[:key2] || "12998 5 Y3 1  .P00"}\r
+\r
+#{args[:key3] || "^n:ds[4U"}
+  EOF
+  request[0..-2]
+end
+
+def server_handshake_76(args = {})
+  request = <<-EOF
+HTTP/1.1 101 WebSocket Protocol Handshake\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Origin: http://example.com\r
+Sec-WebSocket-Location: ws#{args[:secure] ? "s" : ""}://#{args[:host] || "example.com"}#{":#{args[:port]}" if args[:port]}#{args[:path] || "/demo"}\r
+\r
+#{args[:challenge] || "8jKS'y:G*Co,Wxa-"}
+  EOF
+  request[0..-2]
+end
+
+def client_handshake_04(args = {})
+  <<-EOF
+GET #{args[:path] || "/demo"}#{"?#{args[:query]}" if args[:query]} HTTP/1.1\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Host: #{args[:host] || "example.com"}#{":#{args[:port]}" if args[:port]}\r
+Sec-WebSocket-Origin: http://example.com\r
+Sec-WebSocket-Version: #{args[:version] || "4"}\r
+Sec-WebSocket-Key: #{args[:key] || "dGhlIHNhbXBsZSBub25jZQ=="}\r
+\r
+  EOF
+end
+
+def server_handshake_04(args = {})
+  <<-EOF
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: #{args[:accept] || "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="}\r
+\r
+  EOF
+end

data/spec/support/incoming_frames.rb

@@ -0,0 +1,30 @@
+shared_examples_for 'valid_incoming_frame' do
+  let(:decoded_text_array) { decoded_text == "" ? [""] : Array(decoded_text) } # Bug in Ruby 1.8 -> Array("") => [] instead of [""]
+  let(:frame_type_array) { Array(frame_type) }
+
+  its(:class) { should eql(WebSocket::Frame::Incoming) }
+  its(:data) { should eql(encoded_text || "") }
+  its(:version) { should eql(version) }
+  its(:type) { should be_nil }
+  its(:decoded?) { should be_false }
+  its(:to_s) { should eql(encoded_text || "") }
+
+  it "should have specified number of returned frames" do
+    decoded_text_array.each_with_index do |da, index|
+      n = subject.next
+      n.should_not be_nil, "Should return frame for #{da}, #{frame_type_array[index]}"
+      n.class.should eql(WebSocket::Frame::Incoming), "Should be WebSocket::Frame::Incoming, #{n} received instead"
+    end
+    subject.next.should be_nil
+    subject.error.should eql(error)
+  end
+
+  it "should return valid decoded frame for each specified decoded texts" do
+    decoded_text_array.each_with_index do |da, index|
+      f = subject.next
+      f.decoded?.should be_true
+      f.type.should eql(frame_type_array[index])
+      f.to_s.should eql(da)
+    end
+  end
+end

data/spec/support/outgoing_frames.rb

@@ -0,0 +1,14 @@
+shared_examples_for 'valid_outgoing_frame' do
+  its(:class) { should eql(WebSocket::Frame::Outgoing) }
+  its(:version) { should eql(version) }
+  its(:type) { should eql(frame_type) }
+  its(:data) { should eql(decoded_text) }
+  its(:to_s) { should eql(encoded_text) }
+
+  context "after parsing" do
+    before { subject.to_s }
+    its(:error) { should eql(error) }
+    its(:require_sending?) { should eql(require_sending) }
+  end
+
+end

data/websocket.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "websocket/version"
+
+Gem::Specification.new do |s|
+  s.name        = "websocket"
+  s.version     = WebSocket::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bernard Potocki"]
+  s.email       = ["bernard.potocki@imanel.org"]
+  s.homepage    = "http://github.com/imanel/websocket-ruby"
+  s.summary     = %q{Universal Ruby library to handle WebSocket protocol}
+  s.description = %q{Universal Ruby library to handle WebSocket protocol}
+
+  s.add_development_dependency 'rspec', '~> 2.11'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end