thrift 0.22.0 → 0.24.0

data/spec/socket_spec_shared.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -67,38 +68,101 @@ shared_examples_for "a socket" do
     @socket.open
     allow(@handle).to receive(:closed?).and_return(true)
     expect(@socket).not_to be_open
-    expect { @socket.write("fail") }.to raise_error(IOError, "closed stream")
-    expect { @socket.read(10) }.to raise_error(IOError, "closed stream")
+    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException, "closed stream") { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+    expect { @socket.read(10) }.to raise_error(Thrift::TransportException, "closed stream") { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
   end
 
   it "should support the timeout accessor for read" do
     @socket.timeout = 3
     @socket.open
-    expect(IO).to receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
-    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
+    expect(@handle).to receive(:read_nonblock).with(17).and_raise(IO::EAGAINWaitReadable)
+    expect(IO).to receive(:select) do |rd, wr, err, timeout|
+      expect(rd).to eq([@handle])
+      expect(wr).to be_nil
+      expect(err).to be_nil
+      expect(timeout).to be > 0
+      expect(timeout).to be <= 3
+      [[@handle], [], []]
+    end
+    expect(@handle).to receive(:read_nonblock).with(17).and_return("test data")
     expect(@socket.read(17)).to eq("test data")
   end
 
   it "should support the timeout accessor for write" do
     @socket.timeout = 3
     @socket.open
-    expect(IO).to receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
-    expect(@handle).to receive(:write_nonblock).with("test data").and_return(4)
-    expect(@handle).to receive(:write_nonblock).with(" data").and_return(5)
+    write_calls = 0
+    expect(@handle).to receive(:write_nonblock).exactly(3).times do |chunk|
+      write_calls += 1
+      case write_calls
+      when 1
+        expect(chunk).to eq("test data")
+        raise IO::EAGAINWaitWritable
+      when 2
+        expect(chunk).to eq("test data")
+        4
+      when 3
+        expect(chunk).to eq(" data")
+        5
+      end
+    end
+    expect(IO).to receive(:select) do |rd, wr, err, timeout|
+      expect(rd).to be_nil
+      expect(wr).to eq([@handle])
+      expect(err).to be_nil
+      expect(timeout).to be > 0
+      expect(timeout).to be <= 3
+      [[], [@handle], []]
+    end
     expect(@socket.write("test data")).to eq(9)
   end
 
   it "should raise an error when read times out" do
     @socket.timeout = 0.5
     @socket.open
-    expect(IO).to receive(:select).once {sleep(0.5); nil}
+    expect(@handle).to receive(:read_nonblock).with(17).and_raise(IO::EAGAINWaitReadable)
+    expect(IO).to receive(:select).once { sleep(0.6); nil }
     expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
   end
 
   it "should raise an error when write times out" do
     @socket.timeout = 0.5
     @socket.open
-    allow(IO).to receive(:select).with(nil, [@handle], nil, 0.5).and_return(nil)
+    expect(@handle).to receive(:write_nonblock).with("test data").and_raise(IO::EAGAINWaitWritable)
+    expect(IO).to receive(:select).once { sleep(0.6); nil }
     expect { @socket.write("test data") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
   end
+
+  it "should read buffered SSL data without waiting on the raw socket again" do
+    @socket.timeout = 1
+    @socket.open
+
+    expect(@handle).to receive(:read_nonblock).with(4).ordered.and_raise(IO::EAGAINWaitReadable)
+    expect(IO).to receive(:select).once.ordered do |rd, wr, err, timeout|
+      expect(rd).to eq([@handle])
+      expect(wr).to be_nil
+      expect(err).to be_nil
+      expect(timeout).to be > 0
+      expect(timeout).to be <= 1
+      [[@handle], [], []]
+    end
+    expect(@handle).to receive(:read_nonblock).with(4).ordered.and_return("ABCD")
+    expect(@handle).to receive(:read_nonblock).with(5).ordered.and_return("12345")
+
+    expect(@socket.read(4)).to eq("ABCD")
+    expect(@socket.read(5)).to eq("12345")
+  end
+
+  it "should read without timeout using the blocking path" do
+    @socket.timeout = nil
+    @socket.open
+
+    expect(IO).not_to receive(:select)
+    expect(@handle).not_to receive(:read_nonblock)
+    expect(@handle).to receive(:readpartial).with(4).ordered.and_return("ABCD")
+    expect(@handle).to receive(:readpartial).with(5).ordered.and_return("12345")
+
+    expect(@socket.read(4)).to eq("ABCD")
+    expect(@socket.read(5)).to eq("12345")
+  end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -55,7 +56,7 @@ require 'nonblocking_service'
 
 module Fixtures
   COMPACT_PROTOCOL_TEST_STRUCT = Thrift::Test::COMPACT_TEST.dup
-  COMPACT_PROTOCOL_TEST_STRUCT.a_binary = [0,1,2,3,4,5,6,7,8].pack('c*')
+  COMPACT_PROTOCOL_TEST_STRUCT.a_binary = [0, 1, 2, 3, 4, 5, 6, 7, 8].pack('c*')
   COMPACT_PROTOCOL_TEST_STRUCT.set_byte_map = nil
   COMPACT_PROTOCOL_TEST_STRUCT.map_byte_map = nil
 end

data/spec/ssl_server_socket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -21,12 +22,62 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'SSLServerSocket' do
-
   describe Thrift::SSLServerSocket do
     before(:each) do
       @socket = Thrift::SSLServerSocket.new(1234)
     end
 
+    it "should delegate to_io to the underlying SSL server handle" do
+      tcp_server = double("TCPServer")
+      ssl_server = double("SSLServer")
+
+      allow(TCPServer).to receive(:new).with(nil, 1234).and_return(tcp_server)
+      allow(OpenSSL::SSL::SSLServer).to receive(:new).with(tcp_server, nil).and_return(ssl_server)
+      allow(ssl_server).to receive(:to_io).and_return(tcp_server)
+
+      @socket.listen
+      expect(@socket.to_io).to eq(tcp_server)
+    end
+
+    it "should default accepted sockets to a finite client timeout" do
+      expect(@socket.client_timeout).to eq(5)
+    end
+
+    it "should preserve the positional ssl context argument" do
+      context = double("SSLContext")
+      socket = Thrift::SSLServerSocket.new(nil, 1234, context)
+
+      expect(socket.ssl_context).to eq(context)
+      expect(socket.client_timeout).to eq(5)
+    end
+
+    it "should accept a custom client timeout" do
+      context = double("SSLContext")
+      socket = Thrift::SSLServerSocket.new(nil, 1234, context, client_timeout: 2.5)
+
+      expect(socket.ssl_context).to eq(context)
+      expect(socket.client_timeout).to eq(2.5)
+    end
+
+    it "should apply the client timeout to accepted sockets" do
+      tcp_server = double("TCPServer")
+      ssl_server = double("SSLServer")
+      sock = double("SSLSocket")
+
+      allow(TCPServer).to receive(:new).with(nil, 1234).and_return(tcp_server)
+      allow(OpenSSL::SSL::SSLServer).to receive(:new).with(tcp_server, nil).and_return(ssl_server)
+      expect(ssl_server).to receive(:accept).and_return(sock)
+      expect(sock).to receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+      trans = double("Socket")
+      expect(Thrift::Socket).to receive(:new).and_return(trans)
+      expect(trans).to receive(:timeout=).with(Thrift::BaseServerTransport::DEFAULT_CLIENT_TIMEOUT)
+      expect(trans).to receive(:handle=).with(sock)
+
+      @socket.listen
+      expect(@socket.accept).to eq(trans)
+    end
+
     it "should provide a reasonable to_s" do
       expect(@socket.to_s).to eq("ssl(socket(:1234))")
     end

data/spec/ssl_socket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -21,44 +22,60 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'SSLSocket' do
-
   describe Thrift::SSLSocket do
     before(:each) do
       @context = OpenSSL::SSL::SSLContext.new
       @socket = Thrift::SSLSocket.new
+      @addrinfo = double("Addrinfo")
       @simple_socket_handle = double("Handle", :closed? => false)
       allow(@simple_socket_handle).to receive(:close)
-      allow(@simple_socket_handle).to receive(:connect_nonblock)
       allow(@simple_socket_handle).to receive(:setsockopt)
+      allow(@simple_socket_handle).to receive(:wait_readable)
+      allow(@simple_socket_handle).to receive(:wait_writable)
 
-      @handle = double(double("SSLHandle", :connect_nonblock => true, :post_connection_check => true), :closed? => false)
-      allow(@handle).to receive(:connect_nonblock)
+      @handle = double("SSLHandle", :closed? => false)
+      allow(@handle).to receive(:connect).and_return(true)
+      allow(@handle).to receive(:connect_nonblock).and_return(@handle)
       allow(@handle).to receive(:close)
       allow(@handle).to receive(:post_connection_check)
+      allow(@handle).to receive(:sync_close=)
+      allow(@handle).to receive(:to_io).and_return(@simple_socket_handle)
 
-      allow(::Socket).to receive(:new).and_return(@simple_socket_handle)
+      allow(@addrinfo).to receive(:connect).and_return(@simple_socket_handle)
+      allow(Addrinfo).to receive(:foreach).and_yield(@addrinfo)
       allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@handle)
     end
 
     it_should_behave_like "a socket"
 
     it "should raise a TransportException when it cannot open a ssl socket" do
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+      allow(Addrinfo).to receive(:foreach).and_raise(SocketError.new("lookup failed"))
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause).to be_a(SocketError)
+      end
     end
 
     it "should open a ::Socket with default args" do
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
       expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_return(@handle)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect).and_return(true)
       expect(@handle).to receive(:post_connection_check).with('localhost')
       @socket.open
     end
 
     it "should accept host/port options" do
-      handle = double("Handle", :connect_nonblock => true, :setsockopt => nil)
-      allow(::Socket).to receive(:new).and_return(handle)
-      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
+      handle = double("Handle", :closed? => false)
+      allow(handle).to receive(:close)
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 100.0)
+      expect(handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(Addrinfo).to receive(:foreach).with("my.domain", 1234, nil, :STREAM).and_yield(@addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 6000).and_return(handle)
       expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(handle, nil).and_return(@handle)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(@handle)
       expect(@handle).to receive(:post_connection_check).with('my.domain')
       Thrift::SSLSocket.new('my.domain', 1234, 6000, nil).open
     end
@@ -71,6 +88,159 @@ describe 'SSLSocket' do
       expect(Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context).to eq(@context)
     end
 
+    it "should treat zero timeout as blocking for open and handshake" do
+      @socket.timeout = 0
+
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect).and_return(true)
+      expect(@handle).not_to receive(:connect_nonblock)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should use the remaining timeout across ssl wait states" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 102.0, 104.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(:wait_readable)
+      expect(@simple_socket_handle).to receive(:wait_readable).with(3.0).ordered.and_return(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(:wait_writable)
+      expect(@simple_socket_handle).to receive(:wait_writable).with(1.0).ordered.and_return(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should share one timeout budget across tcp fallback and the ssl handshake" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 102.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 3.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(:wait_readable)
+      expect(@simple_socket_handle).to receive(:wait_readable).with(2.0).ordered.and_return(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should continue to the next address after a tcp connect timeout during ssl open" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 2.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should raise TIMED_OUT when ssl handshake wait times out" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 102.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(:wait_readable)
+      expect(@simple_socket_handle).to receive(:wait_readable).with(3.0).and_return(nil)
+      expect(@handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("SSL socket: Timed out establishing session with localhost:9090")
+      end
+    end
+
+    it "should surface tcp open timeout before starting ssl" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+      expect(OpenSSL::SSL::SSLSocket).not_to receive(:new)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("Socket: Timed out opening connection to localhost:9090")
+      end
+    end
+
+    it "should close the raw socket if ssl wrapper creation fails" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_raise(StandardError.new("ssl init failed"))
+      expect(@simple_socket_handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause.message).to eq("ssl init failed")
+      end
+    end
+
+    it "should close the ssl socket when post connection check fails" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost').and_raise(StandardError.new("hostname mismatch"))
+      expect(@handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause.message).to eq("hostname mismatch")
+      end
+    end
+
+    it "should close the ssl socket on an unexpected nonblocking handshake result" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(:unexpected)
+      expect(@handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to include("unexpected SSL connect result")
+      end
+    end
+
+    it "should delegate to_io to the underlying SSL socket handle" do
+      @socket.open
+      expect(@socket.to_io).to eq(@simple_socket_handle)
+    end
+
+    it "should raise IOError when to_io is called on a closed stream" do
+      expect { @socket.to_io }.to raise_error(IOError, 'closed stream')
+    end
+
     it "should provide a reasonable to_s" do
       expect(Thrift::SSLSocket.new('myhost', 8090).to_s).to eq("ssl(socket(myhost:8090))")
     end

data/spec/struct_nested_containers_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -20,7 +21,6 @@
 require 'spec_helper'
 
 describe 'StructNestedContainers' do
-
   def with_type_checking
     saved_type_checking, Thrift.type_checking = Thrift.type_checking, true
     begin
@@ -166,7 +166,7 @@ describe 'StructNestedContainers' do
       with_type_checking do
         a, b = SpecNamespace::NestedMapInMapKey.new, SpecNamespace::NestedMapInMapKey.new
         [a, b].each do |thrift_struct|
-          thrift_struct.value = { { 1 => 2, 3 => 4} => 1, {2 => 3, 4 => 5}  => 2 }
+          thrift_struct.value = { { 1 => 2, 3 => 4} => 1, {2 => 3, 4 => 5} => 2 }
           thrift_struct.validate
         end
         expect(a).to eq(b)

data/spec/struct_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -20,11 +21,10 @@
 require 'spec_helper'
 
 describe 'Struct' do
-
   describe Thrift::Struct do
     it "should iterate over all fields properly" do
       fields = {}
-      SpecNamespace::Foo.new.each_field { |fid,field_info| fields[fid] = field_info }
+      SpecNamespace::Foo.new.each_field { |fid, field_info| fields[fid] = field_info }
       expect(fields).to eq(SpecNamespace::Foo::FIELDS)
     end
 
@@ -51,10 +51,10 @@ describe 'Struct' do
       begin
         struct = SpecNamespace::Foo.new
         struct.ints << 17
-        expect(SpecNamespace::Foo.new.ints).to eq([1,2,2,3])
+        expect(SpecNamespace::Foo.new.ints).to eq([1, 2, 2, 3])
       ensure
         # ensure no leakage to other tests
-        SpecNamespace::Foo::FIELDS[4][:default] = [1,2,2,3]
+        SpecNamespace::Foo::FIELDS[4][:default] = [1, 2, 2, 3]
       end
     end
 
@@ -142,6 +142,34 @@ describe 'Struct' do
       expect(struct.shorts).to eq(Set.new([3, 2]))
     end
 
+    it "rejects negative container sizes while reading" do
+      struct = SpecNamespace::Foo.new
+      prot = Thrift::BaseProtocol.new(double("transport"))
+
+      expect(prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, -1])
+
+      expect {
+        struct.send(:read_field, prot, SpecNamespace::Foo::FIELDS[4])
+      }.to raise_error(Thrift::ProtocolException, "Negative size") { |error|
+        expect(error.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+      }
+    end
+
+    it "does not preallocate arrays from declared list sizes" do
+      struct = SpecNamespace::Foo.new
+      prot = Thrift::BaseProtocol.new(double("transport"))
+      declared_size = 1 << 30
+      sentinel = RuntimeError.new("stop after first element")
+
+      expect(prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, declared_size])
+      expect(prot).to receive(:read_i32).and_raise(sentinel)
+      expect(Array).not_to receive(:new).with(declared_size)
+
+      expect {
+        struct.send(:read_field, prot, SpecNamespace::Foo::FIELDS[4])
+      }.to raise_error(sentinel)
+    end
+
     it "should serialize false boolean fields correctly" do
       b = SpecNamespace::BoolStruct.new(:yesno => false)
       prot = Thrift::BinaryProtocol.new(Thrift::MemoryBufferTransport.new)
@@ -181,7 +209,7 @@ describe 'Struct' do
     end
 
     it "should write itself to the wire" do
-      prot = Thrift::BaseProtocol.new(double("transport")) #mock("Protocol")
+      prot = Thrift::BaseProtocol.new(double("transport")) # mock("Protocol")
       expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Foo")
       expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Hello")
       expect(prot).to receive(:write_struct_end).twice
@@ -227,7 +255,7 @@ describe 'Struct' do
     it "should support optional type-checking in Thrift::Struct.new" do
       Thrift.type_checking = true
       begin
-        expect { SpecNamespace::Hello.new(:greeting => 3) }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
+        expect { SpecNamespace::Hello.new(:greeting => 3) }.to raise_error(Thrift::TypeError, "Expected Types::STRING, received Integer for field greeting")
       ensure
         Thrift.type_checking = false
       end
@@ -238,7 +266,7 @@ describe 'Struct' do
       Thrift.type_checking = true
       begin
         hello = SpecNamespace::Hello.new
-        expect { hello.greeting = 3 }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
+        expect { hello.greeting = 3 }.to raise_error(Thrift::TypeError, "Expected Types::STRING, received Integer for field greeting")
       ensure
         Thrift.type_checking = false
       end
@@ -259,9 +287,9 @@ describe 'Struct' do
         prot = Thrift::BaseProtocol.new(double("trans"))
         expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
         expect(prot).to receive(:write_struct_end)
-        expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
+        expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
         expect(prot).to receive(:write_string).with("something happened")
-        expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
+        expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
         expect(prot).to receive(:write_i32).with(1)
         expect(prot).to receive(:write_field_stop)
         expect(prot).to receive(:write_field_end).twice
@@ -289,5 +317,82 @@ describe 'Struct' do
         e.write(prot)
       end
     end
+
+    it "should handle UUID fields in structs" do
+      struct = SpecNamespace::Foo.new(
+        simple: 42,
+        words: 'test',
+        opt_uuid: '550e8400-e29b-41d4-a716-446655440000'
+      )
+
+      trans = Thrift::MemoryBufferTransport.new
+      prot = Thrift::BinaryProtocol.new(trans)
+
+      struct.write(prot)
+
+      result = SpecNamespace::Foo.new
+      result.read(prot)
+
+      expect(result.simple).to eq(42)
+      expect(result.words).to eq('test')
+      expect(result.opt_uuid).to eq('550e8400-e29b-41d4-a716-446655440000')
+    end
+
+    it "should handle optional UUID fields when unset" do
+      struct = SpecNamespace::Foo.new(simple: 42, words: 'test')
+      expect(struct.opt_uuid).to be_nil
+      expect(struct.opt_uuid?).to be_falsey
+    end
+
+    it "should handle list of UUIDs in SimpleList" do
+      uuids = ['550e8400-e29b-41d4-a716-446655440000', '6ba7b810-9dad-11d1-80b4-00c04fd430c8']
+      struct = SpecNamespace::SimpleList.new(uuids: uuids)
+
+      trans = Thrift::MemoryBufferTransport.new
+      prot = Thrift::CompactProtocol.new(trans)
+
+      struct.write(prot)
+
+      result = SpecNamespace::SimpleList.new
+      result.read(prot)
+
+      expect(result.uuids).to eq(uuids)
+    end
+
+    it "should normalize UUID case to lowercase" do
+      struct = SpecNamespace::Foo.new(opt_uuid: '550E8400-E29B-41D4-A716-446655440000')
+
+      trans = Thrift::MemoryBufferTransport.new
+      prot = Thrift::BinaryProtocol.new(trans)
+
+      struct.write(prot)
+
+      result = SpecNamespace::Foo.new
+      result.read(prot)
+
+      expect(result.opt_uuid).to eq('550e8400-e29b-41d4-a716-446655440000')
+    end
+
+    it "should handle UUID alongside other types in SimpleList" do
+      struct = SpecNamespace::SimpleList.new(
+        bools: [true, false],
+        i32s: [1, 2, 3],
+        strings: ['hello', 'world'],
+        uuids: ['550e8400-e29b-41d4-a716-446655440000', '00000000-0000-0000-0000-000000000000']
+      )
+
+      trans = Thrift::MemoryBufferTransport.new
+      prot = Thrift::BinaryProtocol.new(trans)
+
+      struct.write(prot)
+
+      result = SpecNamespace::SimpleList.new
+      result.read(prot)
+
+      expect(result.bools).to eq([true, false])
+      expect(result.i32s).to eq([1, 2, 3])
+      expect(result.strings).to eq(['hello', 'world'])
+      expect(result.uuids).to eq(['550e8400-e29b-41d4-a716-446655440000', '00000000-0000-0000-0000-000000000000'])
+    end
   end
 end