thrift 0.23.0 → 0.24.0

data/lib/thrift/union.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

data/lib/thrift/uuid.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

data/lib/thrift.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

data/spec/ThriftSpec.thrift

@@ -185,3 +185,19 @@ struct NestedMapInMapKey {
 struct NestedMapInMapValue {
   2: map<byte, map<byte, byte>> value
 }
+
+# Recursive types for the struct/union/exception recursion-depth limit specs (THRIFT-6045).
+struct RecTree {
+  1: list<RecTree> children
+  2: i16 item
+}
+
+union RecUnion {
+  1: list<RecUnion> children
+  2: i32 leaf
+}
+
+exception RecError {
+  1: list<RecError> children
+  2: i32 leaf
+}

data/spec/base_protocol_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
@@ -209,6 +210,25 @@ describe 'BaseProtocol' do
       expect(@prot).to receive(:read_list_end)
       real_skip.call(Thrift::Types::LIST)
     end
+
+    it "should raise DEPTH_LIMIT when max_depth is exhausted" do
+      expect { @prot.skip(Thrift::Types::STRUCT, 0) }.to raise_error(Thrift::ProtocolException) do |e|
+        expect(e.type).to eq(Thrift::ProtocolException::DEPTH_LIMIT)
+      end
+    end
+
+    it "should skip at max_depth=1 without raising" do
+      expect(@prot).to receive(:read_bool).once
+      expect { @prot.skip(Thrift::Types::BOOL, 1) }.not_to raise_error
+    end
+
+    it "should reject negative container sizes while skipping" do
+      expect(@prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, -1])
+
+      expect { @prot.skip(Thrift::Types::LIST) }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+        expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+      end
+    end
   end
 
   describe Thrift::BaseProtocolFactory do

data/spec/base_transport_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
@@ -37,6 +38,25 @@ describe 'BaseTransport' do
       expect(transport.read_all(40)).to eq("10 lettersfifteen lettersmore characters")
     end
 
+    it "should coerce reads to binary encoding" do
+      transport = Thrift::BaseTransport.new
+      expect(transport).to receive(:read).with(3).and_return(+'abc')
+
+      buf = transport.read_all(3)
+
+      expect(buf).to eq('abc')
+      expect(buf.encoding).to eq(Encoding::BINARY)
+    end
+
+    it "should reject negative read sizes" do
+      transport = Thrift::BaseTransport.new
+      expect(transport).not_to receive(:read)
+
+      expect { transport.read_all(-1) }.to raise_error(Thrift::TransportException, "Negative size") do |e|
+        expect(e.type).to eq(Thrift::TransportException::NEGATIVE_SIZE)
+      end
+    end
+
     it "should stub out the rest of the methods" do
       # can't test for stubbiness, so just make sure they're defined
       [:open?, :open, :close, :read, :write, :flush].each do |sym|
@@ -286,7 +306,7 @@ describe 'BaseTransport' do
     end
 
     it "should accept a buffer on input and use it directly" do
-      s = "this is a test"
+      s = +"this is a test"
       @buffer = Thrift::MemoryBufferTransport.new(s)
       expect(@buffer.read(4)).to eq("this")
       s.slice!(-4..-1)
@@ -338,6 +358,21 @@ describe 'BaseTransport' do
       expect(@buffer.read(@buffer.available)).to eq("foo bar")
     end
 
+    it "should force mutable write buffers into binary in place" do
+      s = "abc \u20AC".encode("UTF-8")
+      @buffer.write(s)
+      expect(s.encoding).to eq(Encoding::BINARY)
+      expect(@buffer.read(@buffer.available)).to eq("abc \u20AC".encode("UTF-8").b)
+    end
+
+    it "should not mutate frozen write buffers while forcing binary encoding" do
+      s = "abc \u20AC".encode("UTF-8").freeze
+      @buffer.write(s)
+      expect(s.encoding).to eq(Encoding::UTF_8)
+      expect(s).to be_frozen
+      expect(@buffer.read(@buffer.available)).to eq("abc \u20AC".encode("UTF-8").b)
+    end
+
     it "should throw an EOFError when there isn't enough data in the buffer" do
       @buffer.reset_buffer("")
       expect{ @buffer.read(1) }.to raise_error(EOFError)
@@ -345,6 +380,12 @@ describe 'BaseTransport' do
       @buffer.reset_buffer("1234")
       expect{ @buffer.read(5) }.to raise_error(EOFError)
     end
+
+    it "should reject negative read_all sizes" do
+      expect { @buffer.read_all(-1) }.to raise_error(Thrift::TransportException, "Negative size") do |e|
+        expect(e.type).to eq(Thrift::TransportException::NEGATIVE_SIZE)
+      end
+    end
   end
 
   describe Thrift::IOStreamTransport do

data/spec/binary_protocol_accelerated_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

data/spec/binary_protocol_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

data/spec/binary_protocol_spec_shared.rb

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -109,15 +110,15 @@ shared_examples_for 'a binary protocol' do
     end
   end
 
-  it "should clip numbers out of signed range" do
-    (128..255).each do |i|
-      @prot.write_byte(i)
-      expect(@trans.read(1)).to eq([i].pack('c'))
+  it "should reject bytes outside the signed byte range" do
+    [-129, 128, 255, 2**65].each do |i|
+      expect { @prot.write_byte(i) }.to raise_error(RangeError)
     end
+    expect(@trans.available).to eq(0)
   end
 
-  it "errors out with a Bignum" do
-    expect { @prot.write_byte(2**65) }.to raise_error(RangeError)
+  it "should reject non-integer bytes" do
+    expect { @prot.write_byte(1.5) }.to raise_error(TypeError)
   end
 
   it "should error gracefully when trying to write a nil byte" do
@@ -130,13 +131,19 @@ shared_examples_for 'a binary protocol' do
     [-2**15, -1024, 17, 0, -10000, 1723, 2**15-1].each do |i|
       @prot.write_i16(i)
     end
-    # and try something out of signed range, it should clip
-    @prot.write_i16(2**15 + 5)
 
-    expect(@trans.read(@trans.available)).to eq("\200\000\374\000\000\021\000\000\330\360\006\273\177\377\200\005")
+    expect(@trans.read(@trans.available)).to eq("\200\000\374\000\000\021\000\000\330\360\006\273\177\377")
+  end
 
-    # a Bignum should error
-    # lambda { @prot.write_i16(2**65) }.should raise_error(RangeError)
+  it "should reject i16 values outside the signed i16 range" do
+    [-2**15 - 1, 2**15, 2**65].each do |i|
+      expect { @prot.write_i16(i) }.to raise_error(RangeError)
+    end
+    expect(@trans.available).to eq(0)
+  end
+
+  it "should reject non-integer i16 values" do
+    expect { @prot.write_i16(1.5) }.to raise_error(TypeError)
   end
 
   it "should error gracefully when trying to write a nil i16" do
@@ -149,13 +156,16 @@ shared_examples_for 'a binary protocol' do
     [-2**31, -123123, -2532, -3, 0, 2351235, 12331, 2**31-1].each do |i|
       @prot.write_i32(i)
     end
-    # try something out of signed range, it should clip
     expect(@trans.read(@trans.available)).to eq("\200\000\000\000" + "\377\376\037\r" + "\377\377\366\034" + "\377\377\377\375" + "\000\000\000\000" + "\000#\340\203" + "\000\0000+" + "\177\377\377\377")
-    [2 ** 31 + 5, 2 ** 65 + 5].each do |i|
+    [-2 ** 31 - 1, 2 ** 31, 2 ** 65 + 5].each do |i|
       expect { @prot.write_i32(i) }.to raise_error(RangeError)
     end
   end
 
+  it "should reject non-integer i32 values" do
+    expect { @prot.write_i32(1.5) }.to raise_error(TypeError)
+  end
+
   it "should error gracefully when trying to write a nil i32" do
     expect { @prot.write_i32(nil) }.to raise_error(StandardError, 'nil argument not allowed!')
   end
@@ -166,7 +176,6 @@ shared_examples_for 'a binary protocol' do
     [-2**63, -12356123612323, -23512351, -234, 0, 1231, 2351236, 12361236213, 2**63-1].each do |i|
       @prot.write_i64(i)
     end
-    # try something out of signed range, it should clip
     expect(@trans.read(@trans.available)).to eq(["\200\000\000\000\000\000\000\000",
       "\377\377\364\303\035\244+]",
       "\377\377\377\377\376\231:\341",
@@ -176,13 +185,30 @@ shared_examples_for 'a binary protocol' do
       "\000\000\000\000\000#\340\204",
       "\000\000\000\002\340\311~\365",
       "\177\377\377\377\377\377\377\377"].join(""))
-    expect { @prot.write_i64(2 ** 65 + 5) }.to raise_error(RangeError)
+    [-2 ** 63 - 1, 2 ** 63, 2 ** 65 + 5].each do |i|
+      expect { @prot.write_i64(i) }.to raise_error(RangeError)
+    end
+  end
+
+  it "should reject non-integer i64 values" do
+    expect { @prot.write_i64(1.5) }.to raise_error(TypeError)
   end
 
   it "should error gracefully when trying to write a nil i64" do
     expect { @prot.write_i64(nil) }.to raise_error(StandardError, 'nil argument not allowed!')
   end
 
+  it "should reject out-of-range field ids" do
+    expect { @prot.write_field_begin('foo', Thrift::Types::DOUBLE, -2**15 - 1) }.to raise_error(RangeError)
+    expect { @prot.write_field_begin('foo', Thrift::Types::DOUBLE, 2**15) }.to raise_error(RangeError)
+  end
+
+  it "should reject out-of-range container sizes" do
+    expect { @prot.write_map_begin(Thrift::Types::STRING, Thrift::Types::LIST, -1) }.to raise_error(RangeError)
+    expect { @prot.write_list_begin(Thrift::Types::I16, 2**31) }.to raise_error(RangeError)
+    expect { @prot.write_set_begin(Thrift::Types::I16, 2**31) }.to raise_error(RangeError)
+  end
+
   it "should write a double" do
     # try a random scattering of values, including min/max
     values = [Float::MIN, -1231.15325, -123123.23, -23.23515123, 0, 12351.1325, 523.23, Float::MAX]
@@ -229,6 +255,16 @@ shared_examples_for 'a binary protocol' do
     expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03])
   end
 
+  it 'should write a frozen non-binary string without mutating the input' do
+    buffer = "abc \u20AC".encode('UTF-8').freeze
+    @prot.write_binary(buffer)
+    a = @trans.read(@trans.available)
+    expect(buffer.encoding).to eq(Encoding::UTF_8)
+    expect(buffer).to be_frozen
+    expect(a.encoding).to eq(Encoding::BINARY)
+    expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x07, 0x61, 0x62, 0x63, 0x20, 0xE2, 0x82, 0xAC])
+  end
+
   it "should error gracefully when trying to write a nil string" do
     expect { @prot.write_string(nil) }.to raise_error(StandardError, 'nil argument not allowed!')
   end
@@ -284,6 +320,13 @@ shared_examples_for 'a binary protocol' do
     expect(@prot.read_map_begin).to eq([Thrift::Types::DOUBLE, Thrift::Types::I64, 42])
   end
 
+  it "should reject a negative map size" do
+    @trans.write([Thrift::Types::DOUBLE, Thrift::Types::I64, 0xffffffff].pack("ccN"))
+    expect { @prot.read_map_begin }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+      expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+    end
+  end
+
   # map footer is a noop
 
   it "should read a list header" do
@@ -291,6 +334,13 @@ shared_examples_for 'a binary protocol' do
     expect(@prot.read_list_begin).to eq([Thrift::Types::STRING, 17])
   end
 
+  it "should reject a negative list size" do
+    @trans.write([Thrift::Types::STRING, 0xffffffff].pack("cN"))
+    expect { @prot.read_list_begin }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+      expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+    end
+  end
+
   # list footer is a noop
 
   it "should read a set header" do
@@ -298,6 +348,13 @@ shared_examples_for 'a binary protocol' do
     expect(@prot.read_set_begin).to eq([Thrift::Types::STRING, 17])
   end
 
+  it "should reject a negative set size" do
+    @trans.write([Thrift::Types::STRING, 0xffffffff].pack("cN"))
+    expect { @prot.read_set_begin }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+      expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+    end
+  end
+
   # set footer is a noop
 
   it "should read a bool" do
@@ -371,6 +428,13 @@ shared_examples_for 'a binary protocol' do
     expect(a.encoding).to eq(Encoding::BINARY)
   end
 
+  it "should reject a negative binary size" do
+    @trans.write([0xff, 0xff, 0xff, 0xff].pack('C*'))
+    expect { @prot.read_binary }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+      expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+    end
+  end
+
   it "should perform a complete rpc with no args or return" do
     srv_test(
       proc { |client| client.send_voidMethod() },

data/spec/bytes_spec.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
@@ -44,6 +45,23 @@ describe Thrift::Bytes do
       a = Thrift::Bytes.force_binary_encoding e
       expect(a.encoding).to eq(Encoding::BINARY)
     end
+
+    it 'should return the same frozen binary string unchanged' do
+      e = 'STRING'.b.freeze
+      a = Thrift::Bytes.force_binary_encoding(e)
+      expect(a).to equal(e)
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a).to be_frozen
+    end
+
+    it 'should duplicate a frozen non-binary string before changing encoding' do
+      e = 'STRING'.encode('UTF-8').freeze
+      a = Thrift::Bytes.force_binary_encoding(e)
+      expect(a).not_to equal(e)
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(e.encoding).to eq(Encoding::UTF_8)
+      expect(e).to be_frozen
+    end
   end
 
   describe '.get_string_byte' do
@@ -56,7 +74,7 @@ describe Thrift::Bytes do
 
   describe '.set_string_byte' do
     it 'should set byte value at index' do
-      s = "\x41\x42"
+      s = "\x41\x42".b
       Thrift::Bytes.set_string_byte(s, 0, 0x43)
       expect(s.getbyte(0)).to eq(0x43)
       expect(s).to eq('CB')

data/spec/client_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

data/spec/compact_protocol_spec.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
@@ -21,6 +22,16 @@
 require 'spec_helper'
 
 describe Thrift::CompactProtocol do
+  INTEGER_BOUNDARY_TESTS = {
+    :i32 => [-(2**31), (2**31) - 1],
+    :i64 => [-(2**63), (2**63) - 1]
+  }
+
+  INTEGER_MINIMUM_ENCODINGS = {
+    :i32 => [0xff, 0xff, 0xff, 0xff, 0x0f],
+    :i64 => [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01]
+  }
+
   TESTS = {
     :byte => (-127..127).to_a,
     :i16 => (0..14).map { |shift| [1 << shift, -(1 << shift)] }.flatten.sort,
@@ -71,6 +82,54 @@ describe Thrift::CompactProtocol do
     end
   end
 
+  it "should round-trip signed integer boundaries correctly" do
+    INTEGER_BOUNDARY_TESTS.each_pair do |primitive_type, test_values|
+      test_values.each do |value|
+        trans = Thrift::MemoryBufferTransport.new
+        proto = Thrift::CompactProtocol.new(trans)
+
+        proto.send(writer(primitive_type), value)
+        expect(proto.send(reader(primitive_type))).to eq(value)
+      end
+    end
+  end
+
+  it "should encode signed integer minima with the canonical zigzag varint bytes" do
+    INTEGER_MINIMUM_ENCODINGS.each_pair do |primitive_type, expected_bytes|
+      trans = Thrift::MemoryBufferTransport.new
+      proto = Thrift::CompactProtocol.new(trans)
+
+      proto.send(writer(primitive_type), INTEGER_BOUNDARY_TESTS.fetch(primitive_type).first)
+      expect(trans.read(trans.available).bytes).to eq(expected_bytes)
+    end
+  end
+
+  it "should decode i32 minima from direct canonical zigzag bytes" do
+    trans = Thrift::MemoryBufferTransport.new
+    trans.write(INTEGER_MINIMUM_ENCODINGS[:i32].pack("C*"))
+
+    proto = Thrift::CompactProtocol.new(trans)
+    expect(proto.read_i32).to eq(INTEGER_BOUNDARY_TESTS[:i32].first)
+  end
+
+  it "should decode i64 minima from direct canonical zigzag bytes" do
+    trans = Thrift::MemoryBufferTransport.new
+    trans.write(INTEGER_MINIMUM_ENCODINGS[:i64].pack("C*"))
+
+    proto = Thrift::CompactProtocol.new(trans)
+    expect(proto.read_i64).to eq(INTEGER_BOUNDARY_TESTS[:i64].first)
+  end
+
+  it "should read binary values with multi-byte varint32 lengths" do
+    payload = "x" * 128
+    trans = Thrift::MemoryBufferTransport.new
+    trans.write([0x80, 0x01].pack("C*"))
+    trans.write(payload)
+
+    proto = Thrift::CompactProtocol.new(trans)
+    expect(proto.read_binary).to eq(payload)
+  end
+
   it "should write a uuid" do
     trans = Thrift::MemoryBufferTransport.new
     proto = Thrift::CompactProtocol.new(trans)
@@ -170,6 +229,46 @@ describe Thrift::CompactProtocol do
     expect(Thrift::CompactProtocol.new(trans).to_s).to eq("compact(memory)")
   end
 
+  it "should write a frozen non-binary string without mutating the input" do
+    trans = Thrift::MemoryBufferTransport.new
+    prot = Thrift::CompactProtocol.new(trans)
+    buffer = "abc \u20AC".encode("UTF-8").freeze
+
+    prot.write_binary(buffer)
+
+    expect(buffer.encoding).to eq(Encoding::UTF_8)
+    expect(buffer).to be_frozen
+    expect(trans.read(trans.available).unpack("C*")).to eq([0x07, 0x61, 0x62, 0x63, 0x20, 0xE2, 0x82, 0xAC])
+  end
+
+  it "should reject a varint with more than 10 continuation bytes" do
+    trans = Thrift::MemoryBufferTransport.new(([0x80] * 11).pack("C*"))
+    proto = Thrift::CompactProtocol.new(trans)
+    expect { proto.read_i64 }.to raise_error(Thrift::ProtocolException) do |e|
+      expect(e.type).to eq(Thrift::ProtocolException::INVALID_DATA)
+    end
+  end
+
+  it "should accept a valid 10-byte varint" do
+    trans = Thrift::MemoryBufferTransport.new((([0x80] * 9) + [0x01]).pack("C*"))
+    proto = Thrift::CompactProtocol.new(trans)
+    expect { proto.read_i64 }.not_to raise_error
+  end
+
+  it "should reject a 32-bit varint with more than 5 continuation bytes" do
+    trans = Thrift::MemoryBufferTransport.new(([0x80] * 6).pack("C*"))
+    proto = Thrift::CompactProtocol.new(trans)
+    expect { proto.read_i32 }.to raise_error(Thrift::ProtocolException) do |e|
+      expect(e.type).to eq(Thrift::ProtocolException::INVALID_DATA)
+    end
+  end
+
+  it "should accept a valid 5-byte varint for i32" do
+    trans = Thrift::MemoryBufferTransport.new((([0x80] * 4) + [0x0f]).pack("C*"))
+    proto = Thrift::CompactProtocol.new(trans)
+    expect { proto.read_i32 }.not_to raise_error
+  end
+
   class JankyHandler
     def Janky(i32arg)
       i32arg * 2

data/spec/constants_demo_spec.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

data/spec/exception_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

data/spec/flat_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

data/spec/header_protocol_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

data/spec/header_transport_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
@@ -158,6 +159,50 @@ describe 'HeaderTransport' do
       end
     end
 
+    describe "decompressed size limits" do
+      it "should accept a valid max_decompressed_size" do
+        expect { @trans.set_max_decompressed_size(1024) }.not_to raise_error
+        expect { @trans.set_max_decompressed_size(Thrift::HeaderTransport::MAX_FRAME_SIZE) }.not_to raise_error
+      end
+
+      it "should reject invalid max_decompressed_size" do
+        expect { @trans.set_max_decompressed_size(0) }.to raise_error(ArgumentError)
+        expect { @trans.set_max_decompressed_size(-1) }.to raise_error(ArgumentError)
+        expect { @trans.set_max_decompressed_size(Thrift::HeaderTransport::MAX_FRAME_SIZE + 1) }.to raise_error(ArgumentError)
+      end
+
+      it "should decompress ZLIB payload within the limit" do
+        write_buf = Thrift::MemoryBufferTransport.new
+        writer = Thrift::HeaderTransport.new(write_buf)
+        writer.add_transform(Thrift::HeaderTransformID::ZLIB)
+        writer.write("A" * 1_000)
+        writer.flush
+
+        written_data = write_buf.read(write_buf.available)
+        read_trans = Thrift::HeaderTransport.new(Thrift::MemoryBufferTransport.new(written_data))
+        read_trans.set_max_decompressed_size(2_000)
+
+        expect(read_trans.read(1_000)).to eq("A" * 1_000)
+      end
+
+      it "should raise SIZE_LIMIT TransportException when decompressed output exceeds the limit" do
+        write_buf = Thrift::MemoryBufferTransport.new
+        writer = Thrift::HeaderTransport.new(write_buf)
+        writer.add_transform(Thrift::HeaderTransformID::ZLIB)
+        writer.write("A" * 10_000)
+        writer.flush
+
+        written_data = write_buf.read(write_buf.available)
+        read_trans = Thrift::HeaderTransport.new(Thrift::MemoryBufferTransport.new(written_data))
+        read_trans.set_max_decompressed_size(100)
+
+        expect { read_trans.read(1) }.to raise_error(Thrift::TransportException) do |e|
+          expect(e.type).to eq(Thrift::TransportException::SIZE_LIMIT)
+          expect(e.message).to match(/limit/)
+        end
+      end
+    end
+
     describe "read and frame detection" do
       it "should detect Header format" do
         # Write a Header frame

data/spec/http_client_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

data/spec/json_protocol_spec.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
@@ -223,14 +224,14 @@ describe 'JsonProtocol' do
     it 'should write string' do
       @prot.write_string('this is a test string')
       a = @trans.read(@trans.available)
-      expect(a).to eq('"this is a test string"'.force_encoding(Encoding::BINARY))
+      expect(a).to eq('"this is a test string"'.b)
       expect(a.encoding).to eq(Encoding::BINARY)
     end
 
     it 'should write string with unicode characters' do
       @prot.write_string("this is a test string with unicode characters: \u20AC \u20AD")
       a = @trans.read(@trans.available)
-      expect(a).to eq("\"this is a test string with unicode characters: \u20AC \u20AD\"".force_encoding(Encoding::BINARY))
+      expect(a).to eq("\"this is a test string with unicode characters: \u20AC \u20AD\"".b)
       expect(a.encoding).to eq(Encoding::BINARY)
     end
 
@@ -442,6 +443,13 @@ describe 'JsonProtocol' do
       expect(@prot.read_map_begin).to eq([12, 15, 2])
     end
 
+    it "should reject a negative map size" do
+      @trans.write("[\"rec\",\"lst\",-1,{")
+      expect { @prot.read_map_begin }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+        expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+      end
+    end
+
     it "should read map end" do
       @trans.write("}]")
       expect(@prot.read_map_end).to eq(nil)
@@ -452,6 +460,13 @@ describe 'JsonProtocol' do
       expect(@prot.read_list_begin).to eq([12, 2])
     end
 
+    it "should reject a negative list size" do
+      @trans.write("[\"rec\",-1\"\"")
+      expect { @prot.read_list_begin }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+        expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+      end
+    end
+
     it "should read list end" do
       @trans.write("]")
       expect(@prot.read_list_end).to eq(nil)
@@ -462,6 +477,13 @@ describe 'JsonProtocol' do
       expect(@prot.read_set_begin).to eq([12, 2])
     end
 
+    it "should reject a negative set size" do
+      @trans.write("[\"rec\",-1\"\"")
+      expect { @prot.read_set_begin }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
+        expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
+      end
+    end
+
     it "should read set end" do
       @trans.write("]")
       expect(@prot.read_set_end).to eq(nil)
@@ -502,14 +524,14 @@ describe 'JsonProtocol' do
     end
 
     it 'should read string' do
-      @trans.write('"this is a test string"'.force_encoding(Encoding::BINARY))
+      @trans.write('"this is a test string"'.b)
       a = @prot.read_string
       expect(a).to eq('this is a test string')
       expect(a.encoding).to eq(Encoding::UTF_8)
     end
 
     it 'should read string with unicode characters' do
-      @trans.write('"this is a test string with unicode characters: \u20AC \u20AD"'.force_encoding(Encoding::BINARY))
+      @trans.write('"this is a test string with unicode characters: \u20AC \u20AD"'.b)
       a = @prot.read_string
       expect(a).to eq("this is a test string with unicode characters: \u20AC \u20AD")
       expect(a.encoding).to eq(Encoding::UTF_8)