upfluence-thrift 2.6.8 → 2.7.4

data/spec/client_spec.rb

@@ -20,80 +20,78 @@
 require 'spec_helper'
 
 describe 'Client' do
-
   class ClientSpec
     include Thrift::Client
   end
 
   before(:each) do
-    @prot = mock("MockProtocol")
+    @prot = double('MockProtocol')
     @client = ClientSpec.new(@prot)
   end
 
   describe Thrift::Client do
-    it "should re-use iprot for oprot if not otherwise specified" do
-      @client.instance_variable_get(:'@iprot').should eql(@prot)
-      @client.instance_variable_get(:'@oprot').should eql(@prot)
+    it 'should re-use iprot for oprot if not otherwise specified' do
+      expect(@client.instance_variable_get(:@iprot)).to eql(@prot)
+      expect(@client.instance_variable_get(:@oprot)).to eql(@prot)
     end
 
-    it "should send a test message" do
-      @prot.should_receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::CALL, 1)
-      mock_args = mock('#<TestMessage_args:mock>')
-      mock_args.should_receive(:foo=).with('foo')
-      mock_args.should_receive(:bar=).with(42)
-      mock_args.should_receive(:write).with(@prot)
-      @prot.should_receive(:write_message_end)
-      @prot.should_receive(:trans) do
-        mock('trans').tap do |trans|
-          trans.should_receive(:flush)
+    it 'should send a test message' do
+      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::CALL, 1)
+      mock_args = double('#<TestMessage_args:mock>')
+      expect(mock_args).to receive(:foo=).with('foo')
+      expect(mock_args).to receive(:bar=).with(42)
+      expect(mock_args).to receive(:write).with(@prot)
+      expect(@prot).to receive(:write_message_end)
+      expect(@prot).to receive(:trans) do
+        double('trans').tap do |trans|
+          expect(trans).to receive(:flush)
         end
       end
-      klass = stub("TestMessage_args", :new => mock_args)
-      @client.send_message('testMessage', klass, :foo => 'foo', :bar => 42)
+      klass = double('TestMessage_args', new: mock_args)
+      @client.send_message('testMessage', klass, foo: 'foo', bar: 42)
     end
 
-    it "should increment the sequence id when sending messages" do
-      pending "it seems sequence ids are completely ignored right now" do
-        @prot.should_receive(:write_message_begin).with('testMessage',  Thrift::MessageTypes::CALL, 0).ordered
-        @prot.should_receive(:write_message_begin).with('testMessage2', Thrift::MessageTypes::CALL, 1).ordered
-        @prot.should_receive(:write_message_begin).with('testMessage3', Thrift::MessageTypes::CALL, 2).ordered
-        @prot.stub!(:write_message_end)
-        @prot.stub!(:trans).and_return mock("trans").as_null_object
-        @client.send_message('testMessage', mock("args class").as_null_object)
-        @client.send_message('testMessage2', mock("args class").as_null_object)
-        @client.send_message('testMessage3', mock("args class").as_null_object)
-      end
+    it 'should increment the sequence id when sending messages' do
+      pending 'it seems sequence ids are completely ignored right now'
+      @prot.expect(:write_message_begin).with('testMessage',  Thrift::MessageTypes::CALL, 0).ordered
+      @prot.expect(:write_message_begin).with('testMessage2', Thrift::MessageTypes::CALL, 1).ordered
+      @prot.expect(:write_message_begin).with('testMessage3', Thrift::MessageTypes::CALL, 2).ordered
+      @prot.stub!(:write_message_end)
+      @prot.stub!(:trans).and_return double('trans').as_null_object
+      @client.send_message('testMessage', double('args class').as_null_object)
+      @client.send_message('testMessage2', double('args class').as_null_object)
+      @client.send_message('testMessage3', double('args class').as_null_object)
     end
 
-    it "should receive a test message" do
-      @prot.should_receive(:read_message_begin).and_return [nil, Thrift::MessageTypes::REPLY, 0]
-      @prot.should_receive(:read_message_end)
-      mock_klass = mock("#<MockClass:mock>")
-      mock_klass.should_receive(:read).with(@prot)
-      @client.receive_message(stub("MockClass", :new => mock_klass))
+    it 'should receive a test message' do
+      expect(@prot).to receive(:read_message_begin).and_return [nil, Thrift::MessageTypes::REPLY, 0]
+      expect(@prot).to receive(:read_message_end)
+      mock_klass = double('#<MockClass:mock>')
+      expect(mock_klass).to receive(:read).with(@prot)
+      @client.receive_message(double('MockClass', new: mock_klass))
     end
 
-    it "should handle received exceptions" do
-      @prot.should_receive(:read_message_begin).and_return [nil, Thrift::MessageTypes::EXCEPTION, 0]
-      @prot.should_receive(:read_message_end)
-      Thrift::ApplicationException.should_receive(:new).and_return do
+    it 'should handle received exceptions' do
+      expect(@prot).to receive(:read_message_begin).and_return [nil, Thrift::MessageTypes::EXCEPTION, 0]
+      expect(@prot).to receive(:read_message_end)
+      expect(Thrift::ApplicationException).to receive(:new) do
         StandardError.new.tap do |mock_exc|
-          mock_exc.should_receive(:read).with(@prot)
+          expect(mock_exc).to receive(:read).with(@prot)
         end
       end
-      lambda { @client.receive_message(nil) }.should raise_error(StandardError)
+      expect { @client.receive_message(nil) }.to raise_error(StandardError)
     end
 
-    it "should close the transport if an error occurs while sending a message" do
-      @prot.stub!(:write_message_begin)
-      @prot.should_not_receive(:write_message_end)
-      mock_args = mock("#<TestMessage_args:mock>")
-      mock_args.should_receive(:write).with(@prot).and_raise(StandardError)
-      trans = mock("MockTransport")
-      @prot.stub!(:trans).and_return(trans)
-      trans.should_receive(:close)
-      klass = mock("TestMessage_args", :new => mock_args)
-      lambda { @client.send_message("testMessage", klass) }.should raise_error(StandardError)
+    it 'should close the transport if an error occurs while sending a message' do
+      allow(@prot).to receive(:write_message_begin)
+      expect(@prot).not_to receive(:write_message_end)
+      mock_args = double('#<TestMessage_args:mock>')
+      expect(mock_args).to receive(:write).with(@prot).and_raise(StandardError)
+      trans = double('MockTransport')
+      allow(@prot).to receive(:trans).and_return(trans)
+      expect(trans).to receive(:close)
+      klass = double('TestMessage_args', new: mock_args)
+      expect { @client.send_message('testMessage', klass) }.to raise_error(StandardError)
     end
   end
 end

data/spec/compact_protocol_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -22,17 +21,18 @@ require 'spec_helper'
 
 describe Thrift::CompactProtocol do
   TESTS = {
-    :byte => (-127..127).to_a,
-    :i16 => (0..14).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort,
-    :i32 => (0..30).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort,
-    :i64 => (0..62).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort,
-    :string => ["", "1", "short", "fourteen123456", "fifteen12345678", "unicode characters: \u20AC \u20AD", "1" * 127, "1" * 3000],
-    :binary => ["", "\001", "\001" * 5, "\001" * 14, "\001" * 15, "\001" * 127, "\001" * 3000],
-    :double => [0.0, 1.0, -1.0, 1.1, -1.1, 10000000.1, 1.0/0.0, -1.0/0.0],
-    :bool => [true, false]
+    byte:   (-127..127).to_a,
+    i16:    (0..14).map { |shift| [1 << shift, -(1 << shift)] }.flatten.sort,
+    i32:    (0..30).map { |shift| [1 << shift, -(1 << shift)] }.flatten.sort,
+    i64:    (0..62).map { |shift| [1 << shift, -(1 << shift)] }.flatten.sort,
+    string: ['', '1', 'short', 'fourteen123456', 'fifteen12345678', "unicode characters: \u20AC \u20AD", '1' * 127,
+             '1' * 3000],
+    binary: ['', "\001", "\001" * 5, "\001" * 14, "\001" * 15, "\001" * 127, "\001" * 3000],
+    double: [0.0, 1.0, -1.0, 1.1, -1.1, 10_000_000.1, 1.0 / 0.0, -1.0 / 0.0],
+    bool:   [true, false]
   }
 
-  it "should encode and decode naked primitives correctly" do
+  it 'should encode and decode naked primitives correctly' do
     TESTS.each_pair do |primitive_type, test_values|
       test_values.each do |value|
         # puts "testing #{value}" if primitive_type == :i64
@@ -42,12 +42,12 @@ describe Thrift::CompactProtocol do
         proto.send(writer(primitive_type), value)
         # puts "buf: #{trans.inspect_buffer}" if primitive_type == :i64
         read_back = proto.send(reader(primitive_type))
-        read_back.should == value
+        expect(read_back).to eq(value)
       end
     end
   end
 
-  it "should encode and decode primitives in fields correctly" do
+  it 'should encode and decode primitives in fields correctly' do
     TESTS.each_pair do |primitive_type, test_values|
       final_primitive_type = primitive_type == :binary ? :string : primitive_type
       thrift_type = Thrift::Types.const_get(final_primitive_type.to_s.upcase)
@@ -61,30 +61,30 @@ describe Thrift::CompactProtocol do
         proto.write_field_end
 
         proto = Thrift::CompactProtocol.new(trans)
-        name, type, id = proto.read_field_begin
-        type.should == thrift_type
-        id.should == 15
+        _, type, id = proto.read_field_begin
+        expect(type).to eq(thrift_type)
+        expect(id).to eq(15)
         read_back = proto.send(reader(primitive_type))
-        read_back.should == value
+        expect(read_back).to eq(value)
         proto.read_field_end
       end
     end
   end
 
-  it "should encode and decode a monster struct correctly" do
+  it 'should encode and decode a monster struct correctly' do
     trans = Thrift::MemoryBufferTransport.new
     proto = Thrift::CompactProtocol.new(trans)
 
-    struct = CompactProtoTestStruct.new
+    struct = Thrift::Test::CompactProtoTestStruct.new
     # sets and maps don't hash well... not sure what to do here.
     struct.write(proto)
 
-    struct2 = CompactProtoTestStruct.new
+    struct2 = Thrift::Test::CompactProtoTestStruct.new
     struct2.read(proto)
-    struct2.should == struct
+    expect(struct2).to eq(struct)
   end
 
-  xit "should make method calls correctly" do
+  xit 'should make method calls correctly' do
     r1, w1 = IO.pipe
     r2, w2 = IO.pipe
     client_out_trans = Thrift::IOStreamTransport.new(r2, w1)
@@ -93,44 +93,47 @@ describe Thrift::CompactProtocol do
     client_in_trans = Thrift::IOStreamTransport.new(r1, w2)
     client_in_proto = Thrift::CompactProtocol.new(client_in_trans)
 
-    processor = Srv::Processor.new(JankyHandler.new)
+    processor = Thrift::Test::Srv::Processor.new(JankyHandler.new)
 
-    client = Srv::Client.new(
-      Thrift::BaseClient.new(client_in_proto, client_out_proto)
-    )
-
-    t = Thread.new { processor.process(client_in_proto, client_out_proto) }
-
-    client.Janky(1).should == 2
-
-    t.join
+    client = Thrift::Test::Srv::Client.new(client_in_proto)
+    client.send_Janky(1)
+    # puts client_out_trans.inspect_buffer
+    processor.process(client_out_proto, client_in_proto)
+    expect(client.recv_Janky).to eq(2)
   end
 
-  it "should deal with fields following fields that have non-delta ids" do
-    brcp = BreaksRubyCompactProtocol.new(
-      :field1 => "blah",
-      :field2 => BigFieldIdStruct.new(
-        :field1 => "string1",
-        :field2 => "string2"),
-      :field3 => 3)
+  it 'should deal with fields following fields that have non-delta ids' do
+    brcp = Thrift::Test::BreaksRubyCompactProtocol.new(
+      field1: 'blah',
+      field2: Thrift::Test::BigFieldIdStruct.new(
+        field1: 'string1',
+        field2: 'string2'
+      ),
+      field3: 3
+    )
     ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new)
     bytes = ser.serialize(brcp)
 
     deser = Thrift::Deserializer.new(Thrift::CompactProtocolFactory.new)
-    brcp2 = BreaksRubyCompactProtocol.new
+    brcp2 = Thrift::Test::BreaksRubyCompactProtocol.new
     deser.deserialize(brcp2, bytes)
-    brcp2.should == brcp
+    expect(brcp2).to eq(brcp)
   end
 
-  it "should deserialize an empty map to an empty hash" do
-    struct = SingleMapTestStruct.new(:i32_map => {})
+  it 'should deserialize an empty map to an empty hash' do
+    struct = Thrift::Test::SingleMapTestStruct.new(i32_map: {})
     ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new)
     bytes = ser.serialize(struct)
 
     deser = Thrift::Deserializer.new(Thrift::CompactProtocolFactory.new)
-    struct2 = SingleMapTestStruct.new
+    struct2 = Thrift::Test::SingleMapTestStruct.new
     deser.deserialize(struct2, bytes)
-    struct.should == struct2
+    expect(struct).to eq(struct2)
+  end
+
+  it 'should provide a reasonable to_s' do
+    trans = Thrift::MemoryBufferTransport.new
+    expect(Thrift::CompactProtocol.new(trans).to_s).to eq('compact(memory)')
   end
 
   class JankyHandler
@@ -140,10 +143,20 @@ describe Thrift::CompactProtocol do
   end
 
   def writer(sym)
-    "write_#{sym.to_s}"
+    "write_#{sym}"
   end
 
   def reader(sym)
-    "read_#{sym.to_s}"
+    "read_#{sym}"
+  end
+end
+
+describe Thrift::CompactProtocolFactory do
+  it 'should create a CompactProtocol' do
+    expect(Thrift::CompactProtocolFactory.new.get_protocol(double('MockTransport'))).to be_instance_of(Thrift::CompactProtocol)
+  end
+
+  it 'should provide a reasonable to_s' do
+    expect(Thrift::CompactProtocolFactory.new.to_s).to eq('compact')
   end
 end

data/spec/exception_spec.rb

@@ -24,107 +24,107 @@ describe 'Exception' do
   describe Thrift::Exception do
     it "should have an accessible message" do
       e = Thrift::Exception.new("test message")
-      e.message.should == "test message"
+      expect(e.message).to eq("test message")
     end
   end
 
   describe Thrift::ApplicationException do
     it "should inherit from Thrift::Exception" do
-      Thrift::ApplicationException.superclass.should == Thrift::Exception
+      expect(Thrift::ApplicationException.superclass).to eq(Thrift::Exception)
     end
 
     it "should have an accessible type and message" do
       e = Thrift::ApplicationException.new
-      e.type.should == Thrift::ApplicationException::UNKNOWN
-      e.message.should be_nil
+      expect(e.type).to eq(Thrift::ApplicationException::UNKNOWN)
+      expect(e.message).to be_nil
       e = Thrift::ApplicationException.new(Thrift::ApplicationException::UNKNOWN_METHOD, "test message")
-      e.type.should == Thrift::ApplicationException::UNKNOWN_METHOD
-      e.message.should == "test message"
+      expect(e.type).to eq(Thrift::ApplicationException::UNKNOWN_METHOD)
+      expect(e.message).to eq("test message")
     end
 
     it "should read a struct off of a protocol" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:read_struct_begin).ordered
-      prot.should_receive(:read_field_begin).exactly(3).times.and_return(
+      prot = double("MockProtocol")
+      expect(prot).to receive(:read_struct_begin).ordered
+      expect(prot).to receive(:read_field_begin).exactly(3).times.and_return(
         ["message", Thrift::Types::STRING, 1],
         ["type", Thrift::Types::I32, 2],
         [nil, Thrift::Types::STOP, 0]
       )
-      prot.should_receive(:read_string).ordered.and_return "test message"
-      prot.should_receive(:read_i32).ordered.and_return Thrift::ApplicationException::BAD_SEQUENCE_ID
-      prot.should_receive(:read_field_end).exactly(2).times
-      prot.should_receive(:read_struct_end).ordered
+      expect(prot).to receive(:read_string).ordered.and_return "test message"
+      expect(prot).to receive(:read_i32).ordered.and_return Thrift::ApplicationException::BAD_SEQUENCE_ID
+      expect(prot).to receive(:read_field_end).exactly(2).times
+      expect(prot).to receive(:read_struct_end).ordered
 
       e = Thrift::ApplicationException.new
       e.read(prot)
-      e.message.should == "test message"
-      e.type.should == Thrift::ApplicationException::BAD_SEQUENCE_ID
+      expect(e.message).to eq("test message")
+      expect(e.type).to eq(Thrift::ApplicationException::BAD_SEQUENCE_ID)
     end
 
     it "should skip bad fields when reading a struct" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:read_struct_begin).ordered
-      prot.should_receive(:read_field_begin).exactly(5).times.and_return(
+      prot = double("MockProtocol")
+      expect(prot).to receive(:read_struct_begin).ordered
+      expect(prot).to receive(:read_field_begin).exactly(5).times.and_return(
         ["type", Thrift::Types::I32, 2],
         ["type", Thrift::Types::STRING, 2],
         ["message", Thrift::Types::MAP, 1],
         ["message", Thrift::Types::STRING, 3],
         [nil, Thrift::Types::STOP, 0]
       )
-      prot.should_receive(:read_i32).and_return Thrift::ApplicationException::INVALID_MESSAGE_TYPE
-      prot.should_receive(:skip).with(Thrift::Types::STRING).twice
-      prot.should_receive(:skip).with(Thrift::Types::MAP)
-      prot.should_receive(:read_field_end).exactly(4).times
-      prot.should_receive(:read_struct_end).ordered
+      expect(prot).to receive(:read_i32).and_return Thrift::ApplicationException::INVALID_MESSAGE_TYPE
+      expect(prot).to receive(:skip).with(Thrift::Types::STRING).twice
+      expect(prot).to receive(:skip).with(Thrift::Types::MAP)
+      expect(prot).to receive(:read_field_end).exactly(4).times
+      expect(prot).to receive(:read_struct_end).ordered
 
       e = Thrift::ApplicationException.new
       e.read(prot)
-      e.message.should be_nil
-      e.type.should == Thrift::ApplicationException::INVALID_MESSAGE_TYPE
+      expect(e.message).to be_nil
+      expect(e.type).to eq(Thrift::ApplicationException::INVALID_MESSAGE_TYPE)
     end
 
     it "should write a Thrift::ApplicationException struct to the oprot" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_begin).with("message", Thrift::Types::STRING, 1).ordered
-      prot.should_receive(:write_string).with("test message").ordered
-      prot.should_receive(:write_field_begin).with("type", Thrift::Types::I32, 2).ordered
-      prot.should_receive(:write_i32).with(Thrift::ApplicationException::UNKNOWN_METHOD).ordered
-      prot.should_receive(:write_field_end).twice
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
+      prot = double("MockProtocol")
+      expect(prot).to receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
+      expect(prot).to receive(:write_field_begin).with("message", Thrift::Types::STRING, 1).ordered
+      expect(prot).to receive(:write_string).with("test message").ordered
+      expect(prot).to receive(:write_field_begin).with("type", Thrift::Types::I32, 2).ordered
+      expect(prot).to receive(:write_i32).with(Thrift::ApplicationException::UNKNOWN_METHOD).ordered
+      expect(prot).to receive(:write_field_end).twice
+      expect(prot).to receive(:write_field_stop).ordered
+      expect(prot).to receive(:write_struct_end).ordered
 
       e = Thrift::ApplicationException.new(Thrift::ApplicationException::UNKNOWN_METHOD, "test message")
       e.write(prot)
     end
 
     it "should skip nil fields when writing to the oprot" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_begin).with("message", Thrift::Types::STRING, 1).ordered
-      prot.should_receive(:write_string).with("test message").ordered
-      prot.should_receive(:write_field_end).ordered
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
+      prot = double("MockProtocol")
+      expect(prot).to receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
+      expect(prot).to receive(:write_field_begin).with("message", Thrift::Types::STRING, 1).ordered
+      expect(prot).to receive(:write_string).with("test message").ordered
+      expect(prot).to receive(:write_field_end).ordered
+      expect(prot).to receive(:write_field_stop).ordered
+      expect(prot).to receive(:write_struct_end).ordered
 
       e = Thrift::ApplicationException.new(nil, "test message")
       e.write(prot)
 
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_begin).with("type", Thrift::Types::I32, 2).ordered
-      prot.should_receive(:write_i32).with(Thrift::ApplicationException::BAD_SEQUENCE_ID).ordered
-      prot.should_receive(:write_field_end).ordered
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
+      prot = double("MockProtocol")
+      expect(prot).to receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
+      expect(prot).to receive(:write_field_begin).with("type", Thrift::Types::I32, 2).ordered
+      expect(prot).to receive(:write_i32).with(Thrift::ApplicationException::BAD_SEQUENCE_ID).ordered
+      expect(prot).to receive(:write_field_end).ordered
+      expect(prot).to receive(:write_field_stop).ordered
+      expect(prot).to receive(:write_struct_end).ordered
 
       e = Thrift::ApplicationException.new(Thrift::ApplicationException::BAD_SEQUENCE_ID)
       e.write(prot)
 
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
+      prot = double("MockProtocol")
+      expect(prot).to receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
+      expect(prot).to receive(:write_field_stop).ordered
+      expect(prot).to receive(:write_struct_end).ordered
 
       e = Thrift::ApplicationException.new(nil)
       e.write(prot)
@@ -134,8 +134,8 @@ describe 'Exception' do
   describe Thrift::ProtocolException do
     it "should have an accessible type" do
       prot = Thrift::ProtocolException.new(Thrift::ProtocolException::SIZE_LIMIT, "message")
-      prot.type.should == Thrift::ProtocolException::SIZE_LIMIT
-      prot.message.should == "message"
+      expect(prot.type).to eq(Thrift::ProtocolException::SIZE_LIMIT)
+      expect(prot.message).to eq("message")
     end
   end
 end

data/spec/{gen-rb/extended → extended}/extended_service.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
@@ -108,7 +108,7 @@ module Extended
       ].freeze
 
       METHODS = {
-        'ping' => { args_klass: Ping_args, oneway: false, legacy_annotations: THRIFT_METHOD_PING_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_PING_STRUCTURED_ANNOTATIONS},
+        'ping' => { args_klass: Ping_args, result_klass: Ping_result, oneway: false, legacy_annotations: THRIFT_METHOD_PING_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_PING_STRUCTURED_ANNOTATIONS},
       }.freeze
 
       def execute_ping(args)

data/spec/{gen-rb/extended → extended}/extended_service_constants.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

data/spec/{gen-rb/extended → extended}/extended_service_types.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

data/spec/flat_spec.rb

@@ -32,7 +32,7 @@ describe 'generation' do
      "other_namespace/referenced_constants.rb",
      "other_namespace/referenced_types.rb"
     ].each do |name|
-      File.exist?(File.join(prefix, name)).should_not be_true
+      expect(File.exist?(File.join(prefix, name))).not_to be_truthy
     end
   end
 
@@ -44,19 +44,19 @@ describe 'generation' do
      "referenced_constants.rb",
      "referenced_types.rb"
     ].each do |name|
-      File.exist?(File.join(prefix, name)).should be_true
+      expect(File.exist?(File.join(prefix, name))).to be_truthy
     end
   end
 
   it "has a service class in the right place" do
-    defined?(NamespacedSpecNamespace::NamespacedNonblockingService).should be_true
+    expect(defined?(NamespacedSpecNamespace::NamespacedNonblockingService)).to be_truthy
   end
 
   it "has a struct in the right place" do
-    defined?(NamespacedSpecNamespace::Hello).should be_true
+    expect(defined?(NamespacedSpecNamespace::Hello)).to be_truthy
   end
 
   it "required an included file" do
-    defined?(OtherNamespace::SomeEnum).should be_true
+    expect(defined?(OtherNamespace::SomeEnum)).to be_truthy
   end
 end

data/spec/gen-rb/flat/namespaced_nonblocking_service.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
@@ -412,11 +412,11 @@ module NamespacedSpecNamespace
       ].freeze
 
       METHODS = {
-        'greeting' => { args_klass: Greeting_args, oneway: false, legacy_annotations: THRIFT_METHOD_GREETING_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_GREETING_STRUCTURED_ANNOTATIONS},
-        'block' => { args_klass: Block_args, oneway: false, legacy_annotations: THRIFT_METHOD_BLOCK_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_BLOCK_STRUCTURED_ANNOTATIONS},
+        'greeting' => { args_klass: Greeting_args, result_klass: Greeting_result, oneway: false, legacy_annotations: THRIFT_METHOD_GREETING_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_GREETING_STRUCTURED_ANNOTATIONS},
+        'block' => { args_klass: Block_args, result_klass: Block_result, oneway: false, legacy_annotations: THRIFT_METHOD_BLOCK_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_BLOCK_STRUCTURED_ANNOTATIONS},
         'unblock' => { args_klass: Unblock_args, oneway: true, legacy_annotations: THRIFT_METHOD_UNBLOCK_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_UNBLOCK_STRUCTURED_ANNOTATIONS},
         'shutdown' => { args_klass: Shutdown_args, oneway: true, legacy_annotations: THRIFT_METHOD_SHUTDOWN_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_SHUTDOWN_STRUCTURED_ANNOTATIONS},
-        'sleep' => { args_klass: Sleep_args, oneway: false, legacy_annotations: THRIFT_METHOD_SLEEP_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_SLEEP_STRUCTURED_ANNOTATIONS},
+        'sleep' => { args_klass: Sleep_args, result_klass: Sleep_result, oneway: false, legacy_annotations: THRIFT_METHOD_SLEEP_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_SLEEP_STRUCTURED_ANNOTATIONS},
       }.freeze
 
       def execute_greeting(args)

data/spec/gen-rb/flat/referenced_constants.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

data/spec/gen-rb/flat/referenced_types.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

data/spec/gen-rb/flat/thrift_namespaced_spec_constants.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

data/spec/gen-rb/flat/thrift_namespaced_spec_types.rb

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #