websocket 1.1.4 → 1.2.0

data/spec/frame/incoming_75_spec.rb

@@ -1,9 +1,9 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Incoming frame draft 75' do
+RSpec.describe 'Incoming frame draft 75' do
   let(:version) { 75 }
-  let(:frame) { WebSocket::Frame::Incoming.new(:version => version, :data => encoded_text) }
+  let(:frame) { WebSocket::Frame::Incoming.new(version: version, data: encoded_text) }
   let(:encoded_text) { nil }
   let(:decoded_text) { nil }
   let(:frame_type) { nil }
@@ -12,46 +12,46 @@ describe 'Incoming frame draft 75' do
 
   it_should_behave_like 'valid_incoming_frame'
 
-  context "with valid text frame" do
+  context 'with valid text frame' do
     let(:encoded_text) { "\x00abc\xFF" }
-    let(:decoded_text) { "abc" }
+    let(:decoded_text) { 'abc' }
     let(:frame_type) { :text }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "with two frames" do
+  context 'with two frames' do
     let(:encoded_text) { "\x00abc\xFF\x00def\xFF" }
-    let(:decoded_text) { ["abc", "def"] }
+    let(:decoded_text) { ['abc', 'def'] }
     let(:frame_type)   { [:text, :text] }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "with close frame" do
+  context 'with close frame' do
     let(:encoded_text) { "\xFF\x00" }
-    let(:decoded_text) { "" }
+    let(:decoded_text) { '' }
     let(:frame_type) { :close }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "with incomplete frame" do
+  context 'with incomplete frame' do
     let(:encoded_text) { "\x00test" }
     let(:decoded_text) { nil }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "with invalid frame" do
-    let(:encoded_text) { "invalid" }
+  context 'with invalid frame' do
+    let(:encoded_text) { 'invalid' }
     let(:error) { WebSocket::Error::Frame::Invalid }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "with too long frame" do
-    let(:encoded_text) { "\x00" + "a" * WebSocket.max_frame_size + "\xFF" }
+  context 'with too long frame' do
+    let(:encoded_text) { "\x00" + 'a' * WebSocket.max_frame_size + "\xFF" }
     let(:error) { WebSocket::Error::Frame::TooLong }
 
     it_should_behave_like 'valid_incoming_frame'

data/spec/frame/incoming_common_spec.rb

@@ -1,23 +1,22 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Incoming common frame' do
+RSpec.describe 'Incoming common frame' do
   subject { WebSocket::Frame::Incoming.new }
 
-  its(:version) { should eql(13) }
-  its(:decoded?) { should be_false }
-  # Not implemented yet
-  # its(:error?) { should be_false }
+  its(:version) { is_expected.to eql(13) }
+  its(:decoded?) { is_expected.to be false }
+  its(:error?) { is_expected.to be false }
 
-  it "should allow adding data via <<" do
-    subject.data.should eql("")
-    subject << "test"
-    subject.data.should eql("test")
+  it 'should allow adding data via <<' do
+    expect(subject.data).to eql('')
+    subject << 'test'
+    expect(subject.data).to eql('test')
   end
 
-  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/frame/masking_spec.rb

@@ -1,16 +1,16 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Masking frame draft 07' do
-  it "should encode and decode masked frame correctly" do
-    outgoing_frame = WebSocket::Frame::Outgoing::Client.new(:data => "Hello World", :type => "text")
+RSpec.describe 'Masking frame draft 07' do
+  it 'should encode and decode masked frame correctly' do
+    outgoing_frame = WebSocket::Frame::Outgoing::Client.new(data: 'Hello World', type: 'text')
     outgoing_frame.to_s
-    outgoing_frame.error.should be_nil
-    incoming_frame = WebSocket::Frame::Incoming::Server.new(:data => outgoing_frame.to_s).next
-    incoming_frame.should_not be_nil
-    incoming_frame.class.should eql(WebSocket::Frame::Incoming::Server)
-    incoming_frame.error.should be_nil
-    incoming_frame.decoded?.should be_true
-    incoming_frame.to_s.should eql('Hello World')
+    expect(outgoing_frame.error).to be_nil
+    incoming_frame = WebSocket::Frame::Incoming::Server.new(data: outgoing_frame.to_s).next
+    expect(incoming_frame).not_to be_nil
+    expect(incoming_frame.class).to eql(WebSocket::Frame::Incoming::Server)
+    expect(incoming_frame.error).to be_nil
+    expect(incoming_frame.decoded?).to be true
+    expect(incoming_frame.to_s).to eql('Hello World')
   end
 end

data/spec/frame/outgoing_03_spec.rb

@@ -1,10 +1,10 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Outgoing frame draft 03' do
+RSpec.describe 'Outgoing frame draft 03' do
   let(:version) { 03 }
-  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) { "\x04\x00" }
   let(:frame_type) { :text }
   let(:require_sending) { true }
@@ -13,62 +13,62 @@ describe 'Outgoing frame draft 03' do
 
   it_should_behave_like 'valid_outgoing_frame'
 
-  context "should properly encode close frame" do
+  context 'should properly encode close frame' do
     let(:frame_type) { :close }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x01\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode ping frame" do
+  context 'should properly encode ping frame' do
     let(:frame_type) { :ping }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x02\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode pong frame" do
+  context 'should properly encode pong frame' do
     let(:frame_type) { :pong }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x03\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode text frame" do
-    let(:decoded_text) { "Hello" }
+  context 'should properly encode text frame' do
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x04\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 256 bytes binary frame" do
+  context 'should properly encode 256 bytes binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 256 }
+    let(:decoded_text) { 'a' * 256 }
     let(:encoded_text) { "\x05\x7E\x01\x00" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 64KiB binary frame" do
+  context 'should properly encode 64KiB binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 65536 }
+    let(:decoded_text) { 'a' * 65_536 }
     let(:encoded_text) { "\x05\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + decoded_text }
     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_04_spec.rb

@@ -1,10 +1,10 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Outgoing frame draft 04' do
+RSpec.describe 'Outgoing frame draft 04' do
   let(:version) { 04 }
-  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) { "\x84\x00" }
   let(:frame_type) { :text }
   let(:require_sending) { true }
@@ -13,62 +13,62 @@ describe 'Outgoing frame draft 04' do
 
   it_should_behave_like 'valid_outgoing_frame'
 
-  context "should properly encode close frame" do
+  context 'should properly encode close frame' do
     let(:frame_type) { :close }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x81\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode ping frame" do
+  context 'should properly encode ping frame' do
     let(:frame_type) { :ping }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x82\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode pong frame" do
+  context 'should properly encode pong frame' do
     let(:frame_type) { :pong }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x83\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode text frame" do
-    let(:decoded_text) { "Hello" }
+  context 'should properly encode text frame' do
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x84\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 256 bytes binary frame" do
+  context 'should properly encode 256 bytes binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 256 }
+    let(:decoded_text) { 'a' * 256 }
     let(:encoded_text) { "\x85\x7E\x01\x00" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 64KiB binary frame" do
+  context 'should properly encode 64KiB binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 65536 }
+    let(:decoded_text) { 'a' * 65_536 }
     let(:encoded_text) { "\x85\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + decoded_text }
     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_05_spec.rb

@@ -1,10 +1,10 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Outgoing frame draft 05' do
+RSpec.describe 'Outgoing frame draft 05' do
   let(:version) { 5 }
-  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) { "\x84\x00" }
   let(:frame_type) { :text }
   let(:require_sending) { true }
@@ -13,62 +13,62 @@ describe 'Outgoing frame draft 05' do
 
   it_should_behave_like 'valid_outgoing_frame'
 
-  context "should properly encode close frame" do
+  context 'should properly encode close frame' do
     let(:frame_type) { :close }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x81\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode ping frame" do
+  context 'should properly encode ping frame' do
     let(:frame_type) { :ping }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x82\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode pong frame" do
+  context 'should properly encode pong frame' do
     let(:frame_type) { :pong }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x83\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode text frame" do
-    let(:decoded_text) { "Hello" }
+  context 'should properly encode text frame' do
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x84\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 256 bytes binary frame" do
+  context 'should properly encode 256 bytes binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 256 }
+    let(:decoded_text) { 'a' * 256 }
     let(:encoded_text) { "\x85\x7E\x01\x00" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 64KiB binary frame" do
+  context 'should properly encode 64KiB binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 65536 }
+    let(:decoded_text) { 'a' * 65_536 }
     let(:encoded_text) { "\x85\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + decoded_text }
     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_07_spec.rb

@@ -1,10 +1,10 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Outgoing frame draft 07' do
+RSpec.describe 'Outgoing frame draft 07' do
   let(:version) { 7 }
-  let(:frame) { WebSocket::Frame::Outgoing.new(:version => version, :data => decoded_text, :type => frame_type, :code => close_code) }
-  let(:decoded_text) { "" }
+  let(:frame) { WebSocket::Frame::Outgoing.new(version: version, data: decoded_text, type: frame_type, code: close_code) }
+  let(:decoded_text) { '' }
   let(:close_code) { nil }
   let(:encoded_text) { "\x81\x00" }
   let(:frame_type) { :text }
@@ -14,18 +14,18 @@ describe 'Outgoing frame draft 07' do
 
   it_should_behave_like 'valid_outgoing_frame'
 
-  context "should properly encode close frame without close code" do
+  context 'should properly encode close frame without close code' do
     let(:frame_type) { :close }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x88\x07\x03\xE8" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode close frame with close code" do
+  context 'should properly encode close frame with close code' do
     let(:frame_type) { :close }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:close_code) { 1001 }
     let(:encoded_text) { "\x88\x07\x03\xE9" + decoded_text }
     let(:require_sending) { true }
@@ -33,53 +33,53 @@ describe 'Outgoing frame draft 07' do
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode ping frame" do
+  context 'should properly encode ping frame' do
     let(:frame_type) { :ping }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x89\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode pong frame" do
+  context 'should properly encode pong frame' do
     let(:frame_type) { :pong }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x8a\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode text frame" do
-    let(:decoded_text) { "Hello" }
+  context 'should properly encode text frame' do
+    let(:decoded_text) { 'Hello' }
     let(:encoded_text) { "\x81\x05" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 256 bytes binary frame" do
+  context 'should properly encode 256 bytes binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 256 }
+    let(:decoded_text) { 'a' * 256 }
     let(:encoded_text) { "\x82\x7E\x01\x00" + decoded_text }
     let(:require_sending) { true }
 
     it_should_behave_like 'valid_outgoing_frame'
   end
 
-  context "should properly encode 64KiB binary frame" do
+  context 'should properly encode 64KiB binary frame' do
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 65536 }
+    let(:decoded_text) { 'a' * 65_536 }
     let(:encoded_text) { "\x82\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + decoded_text }
     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 }