thrift 0.22.0 → 0.23.0

data/spec/nonblocking_server_spec.rb

@@ -18,9 +18,9 @@
 #
 
 require 'spec_helper'
+require 'timeout'
 
 describe 'NonblockingServer' do
-
   class Handler
     def initialize
       @queue = Queue.new
@@ -76,7 +76,7 @@ describe 'NonblockingServer' do
       @transport.read(sz)
     end
 
-    def write(buf,sz=nil)
+    def write(buf, sz = nil)
       @transport.write(buf, sz)
     end
 
@@ -166,7 +166,7 @@ describe 'NonblockingServer' do
               break
             end
           end
-          @clients.each { |c,t| t.close and break if c == client } #close the transport
+          @clients.each { |c, t| t.close and break if c == client } # close the transport
         rescue => e
           raise e unless @catch_exceptions
         end
@@ -245,7 +245,7 @@ describe 'NonblockingServer' do
     it "should kill active messages when they don't expire while shutting down" do
       result = Queue.new
       client = setup_client_thread(result)
-      client << [:sleep, 10]
+      client << [:sleep, 10.0]
       sleep 0.1 # start processing the client's message
       @server.shutdown(1)
       @catch_exceptions = true
@@ -260,4 +260,102 @@ describe 'NonblockingServer' do
       expect(@server_thread.join(2)).not_to be_nil
     end
   end
+
+  describe "#{Thrift::NonblockingServer} with TLS transport" do
+    before(:each) do
+      @port = available_port
+      handler = Handler.new
+      processor = SpecNamespace::NonblockingService::Processor.new(handler)
+      @transport = Thrift::SSLServerSocket.new('localhost', @port, create_server_ssl_context)
+      transport_factory = Thrift::FramedTransportFactory.new
+      logger = Logger.new(STDERR)
+      logger.level = Logger::WARN
+      @server = Thrift::NonblockingServer.new(processor, @transport, transport_factory, nil, 5, logger)
+      handler.server = @server
+
+      @server_thread = Thread.new(Thread.current) do |master_thread|
+        begin
+          @server.serve
+        rescue => e
+          master_thread.raise e
+        end
+      end
+
+      @clients = []
+      wait_until_listening
+    end
+
+    after(:each) do
+      @clients.each(&:close)
+      @server.shutdown if @server
+      @server_thread.join(2) if @server_thread
+      @transport.close if @transport
+    end
+
+    it "should handle requests over TLS" do
+      expect(@server_thread).to be_alive
+
+      client = setup_tls_client
+      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
+
+      @server.shutdown
+      expect(@server_thread.join(2)).to be_an_instance_of(Thread)
+    end
+
+    def setup_tls_client
+      transport = Thrift::FramedTransport.new(
+        Thrift::SSLSocket.new('localhost', @port, nil, create_client_ssl_context)
+      )
+      protocol = Thrift::BinaryProtocol.new(transport)
+      client = SpecNamespace::NonblockingService::Client.new(protocol)
+      transport.open
+      @clients << transport
+      client
+    end
+
+    def wait_until_listening
+      Timeout.timeout(2) do
+        until @transport.handle
+          raise "Server thread exited unexpectedly" unless @server_thread.alive?
+          sleep 0.01
+        end
+      end
+    end
+
+    def available_port
+      TCPServer.open('localhost', 0) { |server| server.addr[1] }
+    end
+
+    def ssl_keys_dir
+      File.expand_path('../../../test/keys', __dir__)
+    end
+
+    def create_server_ssl_context
+      OpenSSL::SSL::SSLContext.new.tap do |ctx|
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        if ctx.respond_to?(:min_version=) && OpenSSL::SSL.const_defined?(:TLS1_2_VERSION)
+          ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
+        end
+        ctx.ca_file = File.join(ssl_keys_dir, 'CA.pem')
+        ctx.cert = OpenSSL::X509::Certificate.new(File.read(File.join(ssl_keys_dir, 'server.crt')))
+        ctx.cert_store = OpenSSL::X509::Store.new
+        ctx.cert_store.add_file(File.join(ssl_keys_dir, 'client.pem'))
+        ctx.key = OpenSSL::PKey::RSA.new(File.read(File.join(ssl_keys_dir, 'server.key')))
+      end
+    end
+
+    def create_client_ssl_context
+      OpenSSL::SSL::SSLContext.new.tap do |ctx|
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        if ctx.respond_to?(:min_version=) && OpenSSL::SSL.const_defined?(:TLS1_2_VERSION)
+          ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
+        end
+        ctx.ca_file = File.join(ssl_keys_dir, 'CA.pem')
+        ctx.cert = OpenSSL::X509::Certificate.new(File.read(File.join(ssl_keys_dir, 'client.crt')))
+        ctx.cert_store = OpenSSL::X509::Store.new
+        ctx.cert_store.add_file(File.join(ssl_keys_dir, 'server.pem'))
+        ctx.key = OpenSSL::PKey::RSA.new(File.read(File.join(ssl_keys_dir, 'client.key')))
+      end
+    end
+  end
 end

data/spec/processor_spec.rb

@@ -20,7 +20,6 @@
 require 'spec_helper'
 
 describe 'Processor' do
-
   class ProcessorSpec
     include Thrift::Processor
   end

data/spec/serializer_spec.rb

@@ -20,7 +20,6 @@
 require 'spec_helper'
 
 describe 'Serializer' do
-
   describe Thrift::Serializer do
     it "should serialize structs to binary by default" do
       serializer = Thrift::Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)

data/spec/server_socket_spec.rb

@@ -21,7 +21,6 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'Thrift::ServerSocket' do
-
   describe Thrift::ServerSocket do
     before(:each) do
       @socket = Thrift::ServerSocket.new(1234)
@@ -44,6 +43,7 @@ describe 'Thrift::ServerSocket' do
       expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
       @socket.listen
       sock = double("sock")
+      expect(sock).to receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       expect(handle).to receive(:accept).and_return(sock)
       trans = double("Socket")
       expect(Thrift::Socket).to receive(:new).and_return(trans)

data/spec/server_spec.rb

@@ -19,7 +19,6 @@
 require 'spec_helper'
 
 describe 'Server' do
-
   describe Thrift::BaseServer do
     before(:each) do
       @processor = double("Processor")
@@ -36,9 +35,9 @@ describe 'Server' do
     end
 
     it "should not serve" do
-      expect { @server.serve()}.to raise_error(NotImplementedError)
+      expect { @server.serve() }.to raise_error(NotImplementedError)
     end
-    
+
     it "should provide a reasonable to_s" do
       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
       expect(@trans).to receive(:to_s).once.and_return("trans")
@@ -56,14 +55,14 @@ describe 'Server' do
       @client = double("Client")
       @server = described_class.new(@processor, @serverTrans, @trans, @prot)
     end
-    
+
     it "should provide a reasonable to_s" do
       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
       expect(@trans).to receive(:to_s).once.and_return("trans")
       expect(@prot).to receive(:to_s).once.and_return("prot")
       expect(@server.to_s).to eq("simple(server(prot(trans(serverTrans))))")
     end
-    
+
     it "should serve in the main thread" do
       expect(@serverTrans).to receive(:listen).ordered
       expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
@@ -99,7 +98,7 @@ describe 'Server' do
       expect(@prot).to receive(:to_s).once.and_return("prot")
       expect(@server.to_s).to eq("threaded(server(prot(trans(serverTrans))))")
     end
-    
+
     it "should serve using threads" do
       expect(@serverTrans).to receive(:listen).ordered
       expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
@@ -137,10 +136,10 @@ describe 'Server' do
       expect(@prot).to receive(:to_s).once.and_return("prot")
       expect(@server.to_s).to eq("threadpool(server(prot(trans(server_trans))))")
     end
-    
+
     it "should serve inside a thread" do
       exception_q = @server.instance_variable_get(:@exception_q)
-      expect_any_instance_of(described_class).to receive(:serve) do 
+      expect_any_instance_of(described_class).to receive(:serve) do
         exception_q.push(StandardError.new('ERROR'))
       end
       expect { @server.rescuable_serve }.to(raise_error('ERROR'))
@@ -149,7 +148,7 @@ describe 'Server' do
 
     it "should avoid running the server twice when retrying rescuable_serve" do
       exception_q = @server.instance_variable_get(:@exception_q)
-      expect_any_instance_of(described_class).to receive(:serve) do 
+      expect_any_instance_of(described_class).to receive(:serve) do
         exception_q.push(StandardError.new('ERROR1'))
         exception_q.push(StandardError.new('ERROR2'))
       end

data/spec/socket_spec.rb

@@ -21,7 +21,6 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'Socket' do
-
   describe Thrift::Socket do
     before(:each) do
       @socket = Thrift::Socket.new

data/spec/socket_spec_shared.rb

@@ -67,38 +67,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

@@ -55,7 +55,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

@@ -21,12 +21,23 @@ 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 provide a reasonable to_s" do
       expect(@socket.to_s).to eq("ssl(socket(:1234))")
     end

data/spec/ssl_socket_spec.rb

@@ -21,7 +21,6 @@ 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
@@ -35,6 +34,7 @@ describe 'SSLSocket' do
       allow(@handle).to receive(:connect_nonblock)
       allow(@handle).to receive(:close)
       allow(@handle).to receive(:post_connection_check)
+      allow(@handle).to receive(:to_io).and_return(@simple_socket_handle)
 
       allow(::Socket).to receive(:new).and_return(@simple_socket_handle)
       allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@handle)
@@ -71,6 +71,15 @@ describe 'SSLSocket' do
       expect(Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context).to eq(@context)
     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

@@ -20,7 +20,6 @@
 require 'spec_helper'
 
 describe 'StructNestedContainers' do
-
   def with_type_checking
     saved_type_checking, Thrift.type_checking = Thrift.type_checking, true
     begin
@@ -166,7 +165,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

@@ -20,11 +20,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 +50,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 +141,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 +208,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 +254,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 +265,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 +286,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 +316,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

data/spec/support/header_protocol_helper.rb

@@ -0,0 +1,54 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+module HeaderProtocolHelper
+  def varint32(n)
+    bytes = []
+    loop do
+      if (n & ~0x7f) == 0
+        bytes << n
+        break
+      else
+        bytes << ((n & 0x7f) | 0x80)
+        n >>= 7
+      end
+    end
+    bytes.pack('C*')
+  end
+
+  def build_header_frame(header_data, payload = Thrift::Bytes.empty_byte_buffer, header_words: nil)
+    header_data = Thrift::Bytes.force_binary_encoding(header_data)
+    if header_words.nil?
+      padding = (4 - (header_data.bytesize % 4)) % 4
+      header_data += "\x00" * padding
+      header_words = header_data.bytesize / 4
+    end
+
+    frame_size = 2 + 2 + 4 + 2 + header_data.bytesize + payload.bytesize
+    frame = Thrift::Bytes.empty_byte_buffer
+    frame << [frame_size].pack('N')
+    frame << [Thrift::HeaderTransport::HEADER_MAGIC].pack('n')
+    frame << [0].pack('n')
+    frame << [0].pack('N')
+    frame << [header_words].pack('n')
+    frame << header_data
+    frame << payload
+    frame
+  end
+end