websocket 1.0.0

data/spec/frame/incoming_75_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'Incoming frame draft 75' do
+  let(:version) { 75 }
+  let(:frame) { WebSocket::Frame::Incoming.new(:version => version, :data => encoded_text) }
+  let(:encoded_text) { nil }
+  let(:decoded_text) { nil }
+  let(:frame_type) { nil }
+  let(:error) { nil }
+  subject { frame }
+
+  it_should_behave_like 'valid_incoming_frame'
+
+  context "with valid text frame" do
+    let(:encoded_text) { "\x00abc\xFF" }
+    let(:decoded_text) { "abc" }
+    let(:frame_type) { :text }
+
+    it_should_behave_like 'valid_incoming_frame'
+  end
+
+  context "with two frames" do
+    let(:encoded_text) { "\x00abc\xFF\x00def\xFF" }
+    let(:decoded_text) { ["abc", "def"] }
+    let(:frame_type)   { [:text, :text] }
+
+    it_should_behave_like 'valid_incoming_frame'
+  end
+
+  context "with close frame" do
+    let(:encoded_text) { "\xFF\x00" }
+    let(:decoded_text) { "" }
+    let(:frame_type) { :close }
+
+    it_should_behave_like 'valid_incoming_frame'
+  end
+
+  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" }
+    let(:error) { :invalid_frame }
+
+    it_should_behave_like 'valid_incoming_frame'
+  end
+
+  context "with too long frame" do
+    let(:encoded_text) { "\x00" + "a" * WebSocket::Frame::Handler::Base::MAX_FRAME_SIZE + "\xFF" }
+    let(:error) { :frame_too_long }
+
+    it_should_behave_like('valid_incoming_frame') unless RUBY_PLATFORM == "java"
+  end
+
+end

data/spec/frame/incoming_common_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+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 }
+
+  it "should allow adding data via <<" do
+    subject.data.should eql("")
+    subject << "test"
+    subject.data.should 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)
+  end
+end

data/spec/frame/outgoing_03_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+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(:encoded_text) { "\x04\x00" }
+  let(:frame_type) { :text }
+  let(:require_sending) { true }
+  let(:error) { nil }
+  subject { frame }
+
+  it_should_behave_like 'valid_outgoing_frame'
+
+  context "should properly encode close frame" do
+    let(:frame_type) { :close }
+    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
+    let(:frame_type) { :ping }
+    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
+    let(:frame_type) { :pong }
+    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" }
+    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
+    let(:frame_type) { :binary }
+    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
+    let(:frame_type) { :binary }
+    let(:decoded_text) { "a" * 65536 }
+    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
+    let(:frame_type) { :unknown }
+    let(:decoded_text) { "Hello" }
+    let(:encoded_text) { nil }
+    let(:error) { :unknown_frame_type }
+    let(:require_sending) { false }
+
+    it_should_behave_like 'valid_outgoing_frame'
+  end
+end

data/spec/frame/outgoing_04_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+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(:encoded_text) { "\x84\x00" }
+  let(:frame_type) { :text }
+  let(:require_sending) { true }
+  let(:error) { nil }
+  subject { frame }
+
+  it_should_behave_like 'valid_outgoing_frame'
+
+  context "should properly encode close frame" do
+    let(:frame_type) { :close }
+    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
+    let(:frame_type) { :ping }
+    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
+    let(:frame_type) { :pong }
+    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" }
+    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
+    let(:frame_type) { :binary }
+    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
+    let(:frame_type) { :binary }
+    let(:decoded_text) { "a" * 65536 }
+    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
+    let(:frame_type) { :unknown }
+    let(:decoded_text) { "Hello" }
+    let(:encoded_text) { nil }
+    let(:error) { :unknown_frame_type }
+    let(:require_sending) { false }
+
+    it_should_behave_like 'valid_outgoing_frame'
+  end
+end

data/spec/frame/outgoing_05_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+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(:encoded_text) { "\x84\x00" }
+  let(:frame_type) { :text }
+  let(:require_sending) { true }
+  let(:error) { nil }
+  subject { frame }
+
+  it_should_behave_like 'valid_outgoing_frame'
+
+  context "should properly encode close frame" do
+    let(:frame_type) { :close }
+    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
+    let(:frame_type) { :ping }
+    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
+    let(:frame_type) { :pong }
+    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" }
+    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
+    let(:frame_type) { :binary }
+    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
+    let(:frame_type) { :binary }
+    let(:decoded_text) { "a" * 65536 }
+    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
+    let(:frame_type) { :unknown }
+    let(:decoded_text) { "Hello" }
+    let(:encoded_text) { nil }
+    let(:error) { :unknown_frame_type }
+    let(:require_sending) { false }
+
+    it_should_behave_like 'valid_outgoing_frame'
+  end
+end

data/spec/frame/outgoing_07_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe 'Outgoing frame draft 07' do
+  let(:version) { 7 }
+  let(:frame) { WebSocket::Frame::Outgoing.new(:version => version, :data => decoded_text, :type => frame_type) }
+  let(:decoded_text) { "" }
+  let(:encoded_text) { "\x81\x00" }
+  let(:frame_type) { :text }
+  let(:require_sending) { true }
+  let(:error) { nil }
+  subject { frame }
+
+  it_should_behave_like 'valid_outgoing_frame'
+
+  context "should properly encode close frame" do
+    let(:frame_type) { :close }
+    let(:decoded_text) { "Hello" }
+    let(:encoded_text) { "\x88\x05" + decoded_text }
+    let(:require_sending) { true }
+
+    it_should_behave_like 'valid_outgoing_frame'
+  end
+
+  context "should properly encode ping frame" do
+    let(:frame_type) { :ping }
+    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
+    let(:frame_type) { :pong }
+    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" }
+    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
+    let(:frame_type) { :binary }
+    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
+    let(:frame_type) { :binary }
+    let(:decoded_text) { "a" * 65536 }
+    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
+    let(:frame_type) { :unknown }
+    let(:decoded_text) { "Hello" }
+    let(:encoded_text) { nil }
+    let(:error) { :unknown_frame_type }
+    let(:require_sending) { false }
+
+    it_should_behave_like 'valid_outgoing_frame'
+  end
+end

data/spec/frame/outgoing_75_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+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(:encoded_text) { "\x00\xFF" }
+  let(:frame_type) { :text }
+  let(:require_sending) { true }
+  let(:error) { nil }
+  subject { frame }
+
+  it_should_behave_like 'valid_outgoing_frame'
+
+  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
+    let(:frame_type) { :close }
+    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
+    let(:frame_type) { :unknown }
+    let(:decoded_text) { "Hello" }
+    let(:encoded_text) { nil }
+    let(:error) { :unknown_frame_type }
+    let(:require_sending) { false }
+
+    it_should_behave_like 'valid_outgoing_frame'
+  end
+end

data/spec/frame/outgoing_common_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'Outgoing common frame' do
+  subject { WebSocket::Frame::Outgoing.new }
+
+  its(:version) { should eql(13) }
+  # Not implemented yet
+  # its(:error?) { should 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)
+  end
+end