websocket 1.1.4 → 1.2.0

data/spec/frame/outgoing_75_spec.rb

@@ -1,10 +1,10 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Outgoing frame draft 75' do
+RSpec.describe 'Outgoing frame draft 75' do
   let(:version) { 75 }
-  let(:frame) { WebSocket::Frame::Outgoing.new(:version => version, :data => decoded_text, :type => frame_type) }
-  let(:decoded_text) { "" }
+  let(:frame) { WebSocket::Frame::Outgoing.new(version: version, data: decoded_text, type: frame_type) }
+  let(:decoded_text) { '' }
   let(:encoded_text) { "\x00\xFF" }
   let(:frame_type) { :text }
   let(:require_sending) { true }
@@ -13,26 +13,26 @@ describe 'Outgoing frame draft 75' do
 
   it_should_behave_like 'valid_outgoing_frame'
 
-  context "should properly encode text frame" do
-    let(:decoded_text) { "abc" }
+  context 'should properly encode text frame' do
+    let(:decoded_text) { 'abc' }
     let(:encoded_text) { "\x00abc\xFF" }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode close frame" do
+  context 'should properly encode close frame' do
     let(:frame_type) { :close }
-    let(:decoded_text) { "abc" }
+    let(:decoded_text) { 'abc' }
     let(:encoded_text) { "\xFF\x00" }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should return error for unknown frame type" do
+  context 'should return error for unknown frame type' do
     let(:frame_type) { :unknown }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { nil }
     let(:error) { :unknown_frame_type }
     let(:require_sending) { false }

data/spec/frame/outgoing_common_spec.rb

@@ -1,16 +1,15 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Outgoing common frame' do
+RSpec.describe 'Outgoing common frame' do
   subject { WebSocket::Frame::Outgoing.new }
 
-  its(:version) { should eql(13) }
-  # Not implemented yet
-  # its(:error?) { should be_false }
+  its(:version) { is_expected.to eql(13) }
+  its(:error?) { is_expected.to be false }
 
-  it "should raise error on invalid version" do
-    subject = WebSocket::Frame::Incoming.new(:version => 70)
-    subject.error?.should be_true
-    subject.error.should eql(:unknown_protocol_version)
+  it 'should raise error on invalid version' do
+    subject = WebSocket::Frame::Incoming.new(version: 70)
+    expect(subject.error?).to be true
+    expect(subject.error).to eql(:unknown_protocol_version)
   end
 end

data/spec/handshake/client_04_spec.rb

@@ -1,20 +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 || {})) }
+RSpec.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.handler.send(:key), :version => version }.merge(@request_params || {})) }
-  let(:server_response) { server_handshake_04({ :accept => handshake.handler.send(:accept) }.merge(@request_params || {})) }
+  let(:client_request) { client_handshake_04({ key: handshake.handler.send(:key), version: version }.merge(@request_params || {})) }
+  let(:server_response) { server_handshake_04({ accept: handshake.handler.send(:accept) }.merge(@request_params || {})) }
 
   it_should_behave_like 'all client drafts'
 
-  it "should disallow client with invalid challenge" do
-    @request_params = { :accept => "invalid" }
+  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_handshake_authentication)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
 end

data/spec/handshake/client_75_spec.rb

@@ -1,7 +1,7 @@
 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 || {})) }
+RSpec.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 || {}) }

data/spec/handshake/client_76_spec.rb

@@ -1,20 +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 || {})) }
+RSpec.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.handler.send(:key1), :key2 => handshake.handler.send(:key2), :key3 => handshake.handler.send(:key3) }.merge(@request_params || {})) }
-  let(:server_response) { server_handshake_76({ :challenge => handshake.handler.send(:challenge) }.merge(@request_params || {})) }
+  let(:client_request) { client_handshake_76({ key1: handshake.handler.send(:key1), key2: handshake.handler.send(:key2), key3: handshake.handler.send(:key3) }.merge(@request_params || {})) }
+  let(:server_response) { server_handshake_76({ challenge: handshake.handler.send(:challenge) }.merge(@request_params || {})) }
 
   it_should_behave_like 'all client drafts'
 
-  it "should disallow client with invalid challenge" do
-    @request_params = { :challenge => "invalid" }
+  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_handshake_authentication)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
 end

data/spec/handshake/server_04_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Server draft 04 handshake' do
+RSpec.describe 'Server draft 04 handshake' do
   let(:handshake) { WebSocket::Handshake::Server.new }
   let(:version) { 04 }
   let(:client_request) { client_handshake_04(@request_params || {}) }
@@ -8,11 +8,11 @@ describe 'Server draft 04 handshake' do
 
   it_should_behave_like 'all server drafts'
 
-  it "should disallow request without Sec-WebSocket-Key" do
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
 end

data/spec/handshake/server_75_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Server draft 75 handshake' do
+RSpec.describe 'Server draft 75 handshake' do
   let(:handshake) { WebSocket::Handshake::Server.new }
 
   let(:version) { 75 }

data/spec/handshake/server_76_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Server draft 76 handshake' do
+RSpec.describe 'Server draft 76 handshake' do
   let(:handshake) { WebSocket::Handshake::Server.new }
   let(:version) { 76 }
   let(:client_request) { client_handshake_76(@request_params || {}) }
@@ -8,39 +8,39 @@ describe 'Server draft 76 handshake' do
 
   it_should_behave_like 'all server drafts'
 
-  it "should disallow request without spaces in key 1" do
-    @request_params = { :key1 => "4@146546xW%0l15" }
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
 
-  it "should disallow request without spaces in key 2" do
-    @request_params = { :key2 => "129985Y31.P00" }
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to 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" }
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to 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" }
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
 end

data/spec/spec_helper.rb

@@ -1,10 +1,13 @@
 require 'rspec'
+require 'rspec/its'
 require 'webrick'
 
 require 'websocket'
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
+  config.disable_monkey_patching!
+
   config.before(:suite) do
     WebSocket.max_frame_size = 100 * 1024 # 100kb
   end

data/spec/support/all_client_drafts.rb

@@ -1,98 +1,108 @@
-shared_examples_for 'all client drafts' do
+RSpec.shared_examples_for 'all client drafts' do
   def validate_request
-    handshake.to_s.should eql(client_request)
+    expect(handshake.to_s).to eql(client_request)
 
     handshake << server_response
 
-    handshake.error.should be_nil
-    handshake.should be_finished
-    handshake.should be_valid
+    expect(handshake.error).to be_nil
+    expect(handshake).to be_finished
+    expect(handshake).to be_valid
   end
 
-  it "should be valid" do
+  it 'should be valid' do
     handshake << server_response
 
-    handshake.error.should be_nil
-    handshake.should be_finished
-    handshake.should be_valid
+    expect(handshake.error).to be_nil
+    expect(handshake).to be_finished
+    expect(handshake).to be_valid
   end
 
-  it "should return valid version" do
-    handshake.version.should eql(version)
+  it 'should return valid version' do
+    expect(handshake.version).to eql(version)
   end
 
-  it "should return valid host" do
-    @request_params = { :host => "www.test.cc" }
-    handshake.host.should eql('www.test.cc')
+  it 'should return valid host' do
+    @request_params = { host: 'www.test.cc' }
+    expect(handshake.host).to eql('www.test.cc')
   end
 
-  it "should return valid path" do
-    @request_params = { :path => "/custom" }
-    handshake.path.should eql('/custom')
+  it 'should return valid path' do
+    @request_params = { path: '/custom' }
+    expect(handshake.path).to eql('/custom')
   end
 
-  it "should return valid query" do
-    @request_params = { :query => "aaa=bbb" }
-    handshake.query.should eql("aaa=bbb")
+  it 'should return valid query' do
+    @request_params = { query: 'aaa=bbb' }
+    expect(handshake.query).to eql('aaa=bbb')
   end
 
-  it "should return valid port" do
-    @request_params = { :port => 123 }
-    handshake.port.should eql(123)
+  it 'should return valid port' do
+    @request_params = { port: 123 }
+    expect(handshake.port).to eql(123)
   end
 
-  it "should parse uri" do
-    @request_params = { :uri => "ws://test.example.org:301/test_path?query=true" }
-    handshake.host.should eql('test.example.org')
-    handshake.port.should eql(301)
-    handshake.path.should eql('/test_path')
-    handshake.query.should eql('query=true')
+  it 'should return valid headers' do
+    @request_params = { headers: { 'aaa' => 'bbb' } }
+    expect(handshake.headers).to eql({ 'aaa' => 'bbb' })
   end
 
-  it "should parse url" do
-    @request_params = { :url => "ws://test.example.org:301/test_path?query=true" }
-    handshake.host.should eql('test.example.org')
-    handshake.port.should eql(301)
-    handshake.path.should eql('/test_path')
-    handshake.query.should eql('query=true')
+  it 'should parse uri' do
+    @request_params = { uri: 'ws://test.example.org:301/test_path?query=true' }
+    expect(handshake.host).to eql('test.example.org')
+    expect(handshake.port).to eql(301)
+    expect(handshake.path).to eql('/test_path')
+    expect(handshake.query).to eql('query=true')
   end
 
-  it "should resolve correct path with root server provided" do
-    @request_params = { :url => "ws://test.example.org" }
-    handshake.path.should eql('/')
+  it 'should parse url' do
+    @request_params = { url: 'ws://test.example.org:301/test_path?query=true' }
+    expect(handshake.host).to eql('test.example.org')
+    expect(handshake.port).to eql(301)
+    expect(handshake.path).to eql('/test_path')
+    expect(handshake.query).to eql('query=true')
   end
 
-  it "should return valid response" do
+  it 'should resolve correct path with root server provided' do
+    @request_params = { url: 'ws://test.example.org' }
+    expect(handshake.path).to eql('/')
+  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 custom path" do
-    @request_params = { :path => "/custom" }
+  it 'should allow query in path' do
+    @request_params = { query: 'test=true' }
     validate_request
   end
 
-  it "should allow query in path" do
-    @request_params = { :query => "test=true" }
+  it 'should allow custom port' do
+    @request_params = { port: 123 }
     validate_request
   end
 
-  it "should allow custom port" do
-    @request_params = { :port => 123 }
+  it 'should allow custom headers' do
+    @request_params = { headers: { 'aaa' => 'bbb' } }
     validate_request
   end
 
-  it "should recognize unfinished requests" do
+  it 'should recognize unfinished requests' do
     handshake << server_response[0..-20]
 
-    handshake.should_not be_finished
-    handshake.should_not be_valid
+    expect(handshake).not_to be_finished
+    expect(handshake).not_to be_valid
   end
 
-  it "should disallow requests with invalid request method" do
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:invalid_status_code)
   end
 end

data/spec/support/all_server_drafts.rb

@@ -1,117 +1,117 @@
-shared_examples_for 'all server drafts' do
+RSpec.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)
+    expect(handshake.error).to be_nil
+    expect(handshake).to be_finished
+    expect(handshake).to be_valid
+    expect(handshake.to_s).to eql(server_response)
   end
 
-  it "should be valid" do
+  it 'should be valid' do
     handshake << client_request
 
-    handshake.error.should be_nil
-    handshake.should be_finished
-    handshake.should be_valid
+    expect(handshake.error).to be_nil
+    expect(handshake).to be_finished
+    expect(handshake).to be_valid
   end
 
-  it "should return valid version" do
+  it 'should return valid version' do
     handshake << client_request
 
-    handshake.version.should eql(version)
+    expect(handshake.version).to eql(version)
   end
 
-  it "should return valid host" do
-    @request_params = { :host => "www.test.cc" }
+  it 'should return valid host' do
+    @request_params = { host: 'www.test.cc' }
     handshake << client_request
 
-    handshake.host.should eql('www.test.cc')
+    expect(handshake.host).to eql('www.test.cc')
   end
 
-  it "should return valid path" do
-    @request_params = { :path => "/custom" }
+  it 'should return valid path' do
+    @request_params = { path: '/custom' }
     handshake << client_request
 
-    handshake.path.should eql('/custom')
+    expect(handshake.path).to eql('/custom')
   end
 
-  it "should return valid query" do
-    @request_params = { :path => "/custom?aaa=bbb" }
+  it 'should return valid query' do
+    @request_params = { path: '/custom?aaa=bbb' }
     handshake << client_request
 
-    handshake.query.should eql('aaa=bbb')
+    expect(handshake.query).to eql('aaa=bbb')
   end
 
-  it "should return valid port" do
-    @request_params = { :port => 123 }
+  it 'should return valid port' do
+    @request_params = { port: 123 }
     handshake << client_request
 
-    handshake.port.should eql("123")
+    expect(handshake.port).to eql('123')
   end
 
-  it "should return valid response" do
+  it 'should return valid response' do
     validate_request
   end
 
-  it "should allow custom path" do
-    @request_params = { :path => "/custom" }
+  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" }
+  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 }
+  it 'should allow custom port' do
+    @request_params = { port: 123 }
     validate_request
   end
 
-  it "should recognize unfinished requests" do
+  it 'should recognize unfinished requests' do
     handshake << client_request[0..-10]
 
-    handshake.should_not be_finished
-    handshake.should_not be_valid
+    expect(handshake).not_to be_finished
+    expect(handshake).not_to be_valid
   end
 
-  it "should disallow requests with invalid request method" do
+  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)
+    expect(handshake).to be_finished
+    expect(handshake).not_to be_valid
+    expect(handshake.error).to eql(:get_request_required)
   end
 
-  it "should parse a rack request" do
-    request = WEBrick::HTTPRequest.new( :ServerSoftware => "rspec" )
-    request.parse(StringIO.new(client_request)).should be_true
+  it 'should parse a rack request' do
+    request = WEBrick::HTTPRequest.new(ServerSoftware: 'rspec')
+    expect(request.parse(StringIO.new(client_request))).to be true
     rest    = client_request.slice((request.to_s.length..-1))
 
     handshake.from_rack(request.meta_vars.merge(
-      "rack.input" => StringIO.new(rest)
+      'rack.input' => StringIO.new(rest)
     ))
     validate_request
   end
 
-  it "should parse a hash request" do
-    request = WEBrick::HTTPRequest.new( :ServerSoftware => "rspec" )
-    request.parse(StringIO.new(client_request)).should be_true
+  it 'should parse a hash request' do
+    request = WEBrick::HTTPRequest.new(ServerSoftware: 'rspec')
+    expect(request.parse(StringIO.new(client_request))).to be true
     body = client_request.slice((request.to_s.length..-1))
 
     path = request.path
     query = request.query_string
-    headers = request.header.inject({}) do |hash, header|
+    headers = request.header.reduce({}) do |hash, header|
       hash[header[0]] = header[1].first if header[0] && header[1]
       hash
     end
 
     handshake.from_hash({
-      :headers => headers,
-      :path => path,
-      :query => query,
-      :body => body
+      headers: headers,
+      path: path,
+      query: query,
+      body: body
     })
 
     validate_request