Vendor bundled gems for deployment

3 files changed, 543 insertions, 0 deletions

diff --git a/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/framing_spec.rb b/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/framing_spec.rb
new file mode 100644
index 0000000..b2a8d33
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/framing_spec.rb
@@ -0,0 +1,298 @@
+# encoding: BINARY
+
+require 'helper'
+
+describe EM::WebSocket::Framing03 do
+  class FramingContainer
+    include EM::WebSocket::Framing03
+    
+    def initialize
+      @connection = Object.new
+      def @connection.max_frame_size
+        1000000
+      end
+    end
+
+    def <<(data)
+      @data << data
+      process_data
+    end
+    
+    def debug(*args); end
+  end
+  
+  before :each do
+    @f = FramingContainer.new
+    @f.initialize_framing
+  end
+  
+  describe "basic examples" do
+    it "connection close" do
+      @f.should_receive(:message).with(:close, '', '')
+      @f << 0b00000001
+      @f << 0b00000000
+    end
+    
+    it "ping" do
+      @f.should_receive(:message).with(:ping, '', '')
+      @f << 0b00000010
+      @f << 0b00000000
+    end
+    
+    it "pong" do
+      @f.should_receive(:message).with(:pong, '', '')
+      @f << 0b00000011
+      @f << 0b00000000
+    end
+    
+    it "text" do
+      @f.should_receive(:message).with(:text, '', 'foo')
+      @f << 0b00000100
+      @f << 0b00000011
+      @f << 'foo'
+    end
+    
+    it "Text in two frames" do
+      @f.should_receive(:message).with(:text, '', 'hello world')
+      @f << 0b10000100
+      @f << 0b00000110
+      @f << "hello "
+      @f << 0b00000000
+      @f << 0b00000101
+      @f << "world"
+    end
+    
+    it "2 byte extended payload length text frame" do
+      data = 'a' * 256
+      @f.should_receive(:message).with(:text, '', data)
+      @f << 0b00000100 # Single frame, text
+      @f << 0b01111110 # Length 126 (so read 2 bytes)
+      @f << 0b00000001 # Two bytes in network byte order (256)
+      @f << 0b00000000
+      @f << data
+    end
+  end
+  
+  # These examples are straight from the spec
+  # http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-03#section-4.6
+  describe "examples from the spec" do
+    it "a single-frame text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x04\x05Hello"
+    end
+    
+    it "a fragmented text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x84\x03Hel"
+      @f << "\x00\x02lo"
+    end
+    
+    it "Ping request and response" do
+      @f.should_receive(:message).with(:ping, '', 'Hello')
+      @f << "\x02\x05Hello"
+    end
+    
+    it "256 bytes binary message in a single frame" do
+      data = "a"*256
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x05\x7E\x01\x00" + data
+    end
+    
+    it "64KiB binary message in a single frame" do
+      data = "a"*65536
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x05\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data
+    end
+  end
+
+  describe "other tests" do
+    it "should accept a fragmented unmasked text message in 3 frames" do
+      @f.should_receive(:message).with(:text, '', 'Hello world')
+      @f << "\x84\x03Hel"
+      @f << "\x80\x02lo"
+      @f << "\x00\x06 world"
+    end
+  end
+
+  describe "error cases" do
+    it "should raise an exception on continuation frame without preceeding more frame" do
+      lambda {
+        @f << 0b00000000 # Single frame, continuation
+        @f << 0b00000001 # Length 1
+        @f << 'f'
+      }.should raise_error(EM::WebSocket::WebSocketError, 'Continuation frame not expected')
+    end
+  end
+end
+
+# These examples are straight from the spec
+# http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-03#section-4.6
+describe EM::WebSocket::Framing04 do
+  class FramingContainer04
+    include EM::WebSocket::Framing04
+
+    def initialize
+      @connection = Object.new
+      def @connection.max_frame_size
+        1000000
+      end
+    end
+
+    def <<(data)
+      @data << data
+      process_data
+    end
+
+    def debug(*args); end
+  end
+
+  before :each do
+    @f = FramingContainer04.new
+    @f.initialize_framing
+  end
+
+  describe "examples from the spec" do
+    it "a single-frame text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x84\x05\x48\x65\x6c\x6c\x6f" # "\x84\x05Hello"
+    end
+
+    it "a fragmented text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x04\x03Hel"
+      @f << "\x80\x02lo"
+    end
+
+    it "Ping request" do
+      @f.should_receive(:message).with(:ping, '', 'Hello')
+      @f << "\x82\x05Hello"
+    end
+
+    it "a pong response" do
+      @f.should_receive(:message).with(:pong, '', 'Hello')
+      @f << "\x83\x05Hello"
+    end
+
+    it "256 bytes binary message in a single frame" do
+      data = "a"*256
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x85\x7E\x01\x00" + data
+    end
+
+    it "64KiB binary message in a single frame" do
+      data = "a"*65536
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x85\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data
+    end
+  end
+
+  describe "other tests" do
+    it "should accept a fragmented unmasked text message in 3 frames" do
+      @f.should_receive(:message).with(:text, '', 'Hello world')
+      @f << "\x04\x03Hel"
+      @f << "\x00\x02lo"
+      @f << "\x80\x06 world"
+    end
+  end
+end
+
+describe EM::WebSocket::Framing07 do
+  class FramingContainer07
+    include EM::WebSocket::Framing07
+
+    def initialize
+      @connection = Object.new
+      def @connection.max_frame_size
+        1000000
+      end
+    end
+
+    def <<(data)
+      @data << data
+      process_data
+    end
+
+    def debug(*args); end
+  end
+
+  before :each do
+    @f = FramingContainer07.new
+    @f.initialize_framing
+  end
+
+  # These examples are straight from the spec
+  # http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07#section-4.6
+  describe "examples from the spec" do
+    it "a single-frame unmakedtext message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x81\x05\x48\x65\x6c\x6c\x6f" # "\x84\x05Hello"
+    end
+
+    it "a single-frame masked text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58" # "\x84\x05Hello"
+    end
+
+    it "a fragmented unmasked text message" do
+      @f.should_receive(:message).with(:text, '', 'Hello')
+      @f << "\x01\x03Hel"
+      @f << "\x80\x02lo"
+    end
+
+    it "Ping request" do
+      @f.should_receive(:message).with(:ping, '', 'Hello')
+      @f << "\x89\x05Hello"
+    end
+
+    it "a pong response" do
+      @f.should_receive(:message).with(:pong, '', 'Hello')
+      @f << "\x8a\x05Hello"
+    end
+
+    it "256 bytes binary message in a single unmasked frame" do
+      data = "a"*256
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x82\x7E\x01\x00" + data
+    end
+
+    it "64KiB binary message in a single unmasked frame" do
+      data = "a"*65536
+      @f.should_receive(:message).with(:binary, '', data)
+      @f << "\x82\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + data
+    end
+  end
+
+  describe "other tests" do
+    it "should raise a WSProtocolError if an invalid frame type is requested" do
+      lambda {
+        # Opcode 3 is not supported by this draft
+        @f << "\x83\x05Hello"
+      }.should raise_error(EventMachine::WebSocket::WSProtocolError, "Unknown opcode 3")
+    end
+
+    it "should accept a fragmented unmasked text message in 3 frames" do
+      @f.should_receive(:message).with(:text, '', 'Hello world')
+      @f << "\x01\x03Hel"
+      @f << "\x00\x02lo"
+      @f << "\x80\x06 world"
+    end
+
+    it "should raise if non-fin frame is followed by a non-continuation data frame (continuation frame would be expected)" do
+      lambda {
+        @f << 0b00000001 # Not fin, text
+        @f << 0b00000001 # Length 1
+        @f << 'f'
+        @f << 0b10000001 # fin, text (continutation expected)
+        @f << 0b00000001 # Length 1
+        @f << 'b'
+      }.should raise_error(EM::WebSocket::WebSocketError, 'Continuation frame expected')
+    end
+
+    it "should raise on non-fin control frames (control frames must not be fragmented)" do
+      lambda {
+        @f << 0b00001010 # Not fin, pong (opcode 10)
+        @f << 0b00000000 # Length 1
+      }.should raise_error(EM::WebSocket::WebSocketError, 'Control frames must not be fragmented')
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/handshake_spec.rb b/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/handshake_spec.rb
new file mode 100644
index 0000000..2754ba7
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/handshake_spec.rb
@@ -0,0 +1,216 @@
+require 'helper'
+
+describe EM::WebSocket::Handshake do
+  def handshake(request, secure = false)
+    handshake = EM::WebSocket::Handshake.new(secure)
+    handshake.receive_data(format_request(request))
+    handshake
+  end
+  
+  before :each do
+    @request = {
+      :port => 80,
+      :method => "GET",
+      :path => "/demo",
+      :headers => {
+        'Host' => 'example.com',
+        'Connection' => 'Upgrade',
+        'Sec-WebSocket-Key2' => '12998 5 Y3 1  .P00',
+        'Sec-WebSocket-Protocol' => 'sample',
+        'Upgrade' => 'WebSocket',
+        'Sec-WebSocket-Key1' => '4 @1  46546xW%0l 1 5',
+        'Origin' => 'http://example.com'
+      },
+      :body => '^n:ds[4U'
+    }
+    @secure_request = @request.merge(:port => 443)
+
+    @response = {
+      :headers => {
+        "Upgrade" => "WebSocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Location" => "ws://example.com/demo",
+        "Sec-WebSocket-Origin" => "http://example.com",
+        "Sec-WebSocket-Protocol" => "sample"
+      },
+      :body => "8jKS\'y:G*Co,Wxa-"
+    }
+    @secure_response = @response.merge(:headers => @response[:headers].merge('Sec-WebSocket-Location' => "wss://example.com/demo"))
+  end
+  
+  it "should handle good request" do
+    handshake(@request).should succeed_with_upgrade(@response)
+  end
+  
+  it "should handle good request to secure default port if secure mode is enabled" do
+    handshake(@secure_request, true).
+      should succeed_with_upgrade(@secure_response)
+  end
+  
+  it "should not handle good request to secure default port if secure mode is disabled" do
+    handshake(@secure_request, false).
+      should_not succeed_with_upgrade(@secure_response)
+  end
+  
+  it "should handle good request on nondefault port" do
+    @request[:port] = 8081
+    @request[:headers]['Host'] = 'example.com:8081'
+    @response[:headers]['Sec-WebSocket-Location'] =
+      'ws://example.com:8081/demo'
+
+    handshake(@request).should succeed_with_upgrade(@response)
+  end
+  
+  it "should handle good request to secure nondefault port" do
+    @secure_request[:port] = 8081
+    @secure_request[:headers]['Host'] = 'example.com:8081'
+    @secure_response[:headers]['Sec-WebSocket-Location'] = 'wss://example.com:8081/demo'
+    
+    handshake(@secure_request, true).
+      should succeed_with_upgrade(@secure_response)
+  end
+  
+  it "should handle good request with no protocol" do
+    @request[:headers].delete('Sec-WebSocket-Protocol')
+    @response[:headers].delete("Sec-WebSocket-Protocol")
+
+    handshake(@request).should succeed_with_upgrade(@response)
+  end
+  
+  it "should handle extra headers by simply ignoring them" do
+    @request[:headers]['EmptyValue'] = ""
+    @request[:headers]['AKey'] = "AValue"
+
+    handshake(@request).should succeed_with_upgrade(@response)
+  end
+  
+  it "should raise error on HTTP request" do
+    @request[:headers] = {
+      'Host' => 'www.google.com',
+      'User-Agent' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 GTB6 GTBA',
+      'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Language' => 'en-us,en;q=0.5',
+      'Accept-Encoding' => 'gzip,deflate',
+      'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+      'Keep-Alive' => '300',
+      'Connection' => 'keep-alive',
+    }
+    
+    handshake(@request).should fail_with_error(EM::WebSocket::HandshakeError)
+  end
+  
+  it "should raise error on wrong method" do
+    @request[:method] = 'POST'
+
+    handshake(@request).should fail_with_error(EM::WebSocket::HandshakeError)
+  end
+  
+  it "should raise error if upgrade header incorrect" do
+    @request[:headers]['Upgrade'] = 'NonWebSocket'
+
+    handshake(@request).should fail_with_error(EM::WebSocket::HandshakeError)
+  end
+  
+  it "should raise error if Sec-WebSocket-Protocol is empty" do
+    @request[:headers]['Sec-WebSocket-Protocol'] = ''
+
+    handshake(@request).should fail_with_error(EM::WebSocket::HandshakeError)
+  end
+  
+  %w[Sec-WebSocket-Key1 Sec-WebSocket-Key2].each do |header|
+    it "should raise error if #{header} has zero spaces" do
+      @request[:headers][header] = 'nospaces'
+
+      handshake(@request).
+        should fail_with_error(EM::WebSocket::HandshakeError, 'Websocket Key1 or Key2 does not contain spaces - this is a symptom of a cross-protocol attack')
+    end
+  end
+  
+  it "should raise error if Sec-WebSocket-Key1 is missing" do
+    @request[:headers].delete("Sec-WebSocket-Key1")
+
+    # The error message isn't correct since key1 is used to heuristically
+    # determine the protocol version in use, however this test at least checks
+    # that the handshake does correctly fail
+    handshake(@request).
+      should fail_with_error(EM::WebSocket::HandshakeError, 'Extra bytes after header')
+  end
+
+  it "should raise error if Sec-WebSocket-Key2 is missing" do
+    @request[:headers].delete("Sec-WebSocket-Key2")
+
+    handshake(@request).
+      should fail_with_error(EM::WebSocket::HandshakeError, 'WebSocket key1 or key2 is missing')
+  end
+
+  it "should raise error if spaces do not divide numbers in Sec-WebSocket-Key* " do
+    @request[:headers]['Sec-WebSocket-Key2'] = '12998 5 Y3 1.P00'
+
+    handshake(@request).
+      should fail_with_error(EM::WebSocket::HandshakeError, 'Invalid Key "12998 5 Y3 1.P00"')
+  end
+  
+  it "should raise error if the HTTP header is empty" do
+    handshake = EM::WebSocket::Handshake.new(false)
+    handshake.receive_data("\r\n\r\nfoobar")
+    
+    handshake.
+      should fail_with_error(EM::WebSocket::HandshakeError, 'Invalid HTTP header: Could not parse data entirely (4 != 10)')
+  end
+
+  # This might seems crazy, but very occasionally we saw multiple "Upgrade:
+  # WebSocket" headers in the wild. RFC 4.2.1 isn't particularly clear on this
+  # point, so for now I have decided not to accept --@mloughran
+  it "should raise error on multiple upgrade headers" do
+    handshake = EM::WebSocket::Handshake.new(false)
+
+    # Add a duplicate upgrade header
+    headers = format_request(@request)
+    upgrade_header = "Upgrade: WebSocket\r\n"
+    headers.gsub!(upgrade_header, "#{upgrade_header}#{upgrade_header}")
+
+    handshake.receive_data(headers)
+
+    handshake.errback { |e|
+      e.class.should == EM::WebSocket::HandshakeError
+      e.message.should == 'Invalid upgrade header: ["WebSocket", "WebSocket"]'
+    }
+  end
+  
+  it "should cope with requests where the header is split" do
+    request = format_request(@request)
+    incomplete_request = request[0...(request.length / 2)]
+    rest = request[(request.length / 2)..-1]
+    handshake = EM::WebSocket::Handshake.new(false)
+    handshake.receive_data(incomplete_request)
+    
+    handshake.instance_variable_get(:@deferred_status).should == nil
+    
+    # Send the remaining header
+    handshake.receive_data(rest)
+    
+    handshake(@request).should succeed_with_upgrade(@response)
+  end
+  
+  it "should cope with requests where the third key is split" do
+    request = format_request(@request)
+    # Removes last two bytes of the third key
+    incomplete_request = request[0..-3]
+    rest = request[-2..-1]
+    handshake = EM::WebSocket::Handshake.new(false)
+    handshake.receive_data(incomplete_request)
+    
+    handshake.instance_variable_get(:@deferred_status).should == nil
+    
+    # Send the remaining third key
+    handshake.receive_data(rest)
+    
+    handshake(@request).should succeed_with_upgrade(@response)
+  end
+
+  it "should fail if the request URI is invalid" do
+    @request[:path] = "/%"
+    handshake(@request).should \
+      fail_with_error(EM::WebSocket::HandshakeError, 'Invalid request URI: /%')
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/masking_spec.rb b/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/masking_spec.rb
new file mode 100644
index 0000000..065aa95
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/em-websocket-0.5.3/spec/unit/masking_spec.rb
@@ -0,0 +1,29 @@
+# encoding: BINARY
+
+require 'helper'
+
+describe EM::WebSocket::MaskedString do
+  it "should allow reading 4 byte mask and unmasking byte / bytes" do
+    t = EM::WebSocket::MaskedString.new("\x00\x00\x00\x01\x00\x01\x00\x01")
+    t.read_mask
+    t.getbyte(3).should == 0x00
+    t.getbytes(4, 4).should == "\x00\x01\x00\x00"
+    t.getbytes(5, 3).should ==     "\x01\x00\x00"
+  end
+
+  it "should return nil from getbyte if index requested is out of range" do
+    t = EM::WebSocket::MaskedString.new("\x00\x00\x00\x00\x53")
+    t.read_mask
+    t.getbyte(4).should == 0x53
+    t.getbyte(5).should == nil
+  end
+  
+  it "should allow switching masking on and off" do
+    t = EM::WebSocket::MaskedString.new("\x02\x00\x00\x00\x03")
+    t.getbyte(4).should == 0x03
+    t.read_mask
+    t.getbyte(4).should == 0x01
+    t.unset_mask
+    t.getbyte(4).should == 0x03
+  end
+end