upfluence-thrift 1.1.0 → 2.3.1

data/spec/binary_protocol_spec_shared.rb

@@ -38,25 +38,25 @@ shared_examples_for 'a binary protocol' do
 
   it "should make strict_write readable" do
     @prot.strict_write.should eql(true)
-  end    
+  end
 
   it "should write the message header" do
     @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
     @trans.read(@trans.available).should == [protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::CALL, "testMessage".size, "testMessage", 17].pack("NNa11N")
   end
-  
+
   it "should write the message header without version when writes are not strict" do
     @prot = protocol_class.new(@trans, true, false) # no strict write
     @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
     @trans.read(@trans.available).should == "\000\000\000\vtestMessage\001\000\000\000\021"
   end
-  
+
   it "should write the message header with a version when writes are strict" do
     @prot = protocol_class.new(@trans) # strict write
     @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
     @trans.read(@trans.available).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
   end
-  
+
 
   # message footer is a noop
 
@@ -64,44 +64,44 @@ shared_examples_for 'a binary protocol' do
     @prot.write_field_begin('foo', Thrift::Types::DOUBLE, 3)
     @trans.read(@trans.available).should == [Thrift::Types::DOUBLE, 3].pack("cn")
   end
-  
+
   # field footer is a noop
-  
+
   it "should write the STOP field" do
     @prot.write_field_stop
     @trans.read(1).should == "\000"
   end
-  
+
   it "should write the map header" do
     @prot.write_map_begin(Thrift::Types::STRING, Thrift::Types::LIST, 17)
     @trans.read(@trans.available).should == [Thrift::Types::STRING, Thrift::Types::LIST, 17].pack("ccN");
   end
-   
+
   # map footer is a noop
-  
+
   it "should write the list header" do
     @prot.write_list_begin(Thrift::Types::I16, 42)
     @trans.read(@trans.available).should == [Thrift::Types::I16, 42].pack("cN")
   end
-  
+
   # list footer is a noop
-  
+
   it "should write the set header" do
     @prot.write_set_begin(Thrift::Types::I16, 42)
     @trans.read(@trans.available).should == [Thrift::Types::I16, 42].pack("cN")
   end
-  
+
   it "should write a bool" do
     @prot.write_bool(true)
     @prot.write_bool(false)
     @trans.read(@trans.available).should == "\001\000"
   end
-  
+
   it "should treat a nil bool as false" do
     @prot.write_bool(nil)
     @trans.read(1).should == "\000"
   end
-  
+
   it "should write a byte" do
     # byte is small enough, let's check -128..127
     (-128..127).each do |i|
@@ -117,11 +117,11 @@ shared_examples_for 'a binary protocol' do
     # and lastly, a Bignum is going to error out
     lambda { @prot.write_byte(2**65) }.should raise_error(RangeError)
   end
-  
+
   it "should error gracefully when trying to write a nil byte" do
     lambda { @prot.write_byte(nil) }.should raise_error
   end
-  
+
   it "should write an i16" do
     # try a random scattering of values
     # include the signed i16 minimum/maximum
@@ -130,17 +130,17 @@ shared_examples_for 'a binary protocol' do
     end
     # and try something out of signed range, it should clip
     @prot.write_i16(2**15 + 5)
-    
+
     @trans.read(@trans.available).should == "\200\000\374\000\000\021\000\000\330\360\006\273\177\377\200\005"
-    
+
     # a Bignum should error
     # lambda { @prot.write_i16(2**65) }.should raise_error(RangeError)
   end
-  
+
   it "should error gracefully when trying to write a nil i16" do
     lambda { @prot.write_i16(nil) }.should raise_error
   end
-  
+
   it "should write an i32" do
     # try a random scattering of values
     # include the signed i32 minimum/maximum
@@ -150,14 +150,14 @@ shared_examples_for 'a binary protocol' do
     # try something out of signed range, it should clip
     @trans.read(@trans.available).should == "\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|
-      lambda { @prot.write_i32(i) }.should raise_error(RangeError)  
+      lambda { @prot.write_i32(i) }.should raise_error(RangeError)
     end
   end
-  
+
   it "should error gracefully when trying to write a nil i32" do
     lambda { @prot.write_i32(nil) }.should raise_error
   end
-  
+
   it "should write an i64" do
     # try a random scattering of values
     # try the signed i64 minimum/maximum
@@ -176,11 +176,11 @@ shared_examples_for 'a binary protocol' do
       "\177\377\377\377\377\377\377\377"].join("")
     lambda { @prot.write_i64(2 ** 65 + 5) }.should raise_error(RangeError)
   end
-  
+
   it "should error gracefully when trying to write a nil i64" do
     lambda { @prot.write_i64(nil) }.should raise_error
   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]
@@ -189,7 +189,7 @@ shared_examples_for 'a binary protocol' do
       @trans.read(@trans.available).should == [f].pack("G")
     end
   end
-  
+
   it "should error gracefully when trying to write a nil double" do
     lambda { @prot.write_double(nil) }.should raise_error
   end
@@ -246,28 +246,28 @@ shared_examples_for 'a binary protocol' do
   it "should error gracefully when trying to write a nil string" do
     lambda { @prot.write_string(nil) }.should raise_error
   end
-  
+
   it "should write the message header without version when writes are not strict" do
     @prot = protocol_class.new(@trans, true, false) # no strict write
     @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
     @trans.read(@trans.available).should == "\000\000\000\vtestMessage\001\000\000\000\021"
   end
-    
+
   it "should write the message header with a version when writes are strict" do
     @prot = protocol_class.new(@trans) # strict write
     @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
     @trans.read(@trans.available).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
   end
-  
+
   # message footer is a noop
-  
+
   it "should read a field header" do
     @trans.write([Thrift::Types::STRING, 3].pack("cn"))
     @prot.read_field_begin.should == [nil, Thrift::Types::STRING, 3]
   end
-  
+
   # field footer is a noop
-  
+
   it "should read a stop field" do
     @trans.write([Thrift::Types::STOP].pack("c"));
     @prot.read_field_begin.should == [nil, Thrift::Types::STOP, 0]
@@ -277,36 +277,36 @@ shared_examples_for 'a binary protocol' do
     @trans.write([Thrift::Types::DOUBLE, Thrift::Types::I64, 42].pack("ccN"))
     @prot.read_map_begin.should == [Thrift::Types::DOUBLE, Thrift::Types::I64, 42]
   end
-  
+
   # map footer is a noop
-  
+
   it "should read a list header" do
     @trans.write([Thrift::Types::STRING, 17].pack("cN"))
     @prot.read_list_begin.should == [Thrift::Types::STRING, 17]
   end
-  
+
   # list footer is a noop
-  
+
   it "should read a set header" do
     @trans.write([Thrift::Types::STRING, 17].pack("cN"))
     @prot.read_set_begin.should == [Thrift::Types::STRING, 17]
   end
-  
+
   # set footer is a noop
-  
+
   it "should read a bool" do
     @trans.write("\001\000");
     @prot.read_bool.should == true
     @prot.read_bool.should == false
   end
-  
+
   it "should read a byte" do
     [-128, -57, -3, 0, 17, 24, 127].each do |i|
       @trans.write([i].pack("c"))
       @prot.read_byte.should == i
     end
   end
-  
+
   it "should read an i16" do
     # try a scattering of values, including min/max
     [-2**15, -5237, -353, 0, 1527, 2234, 2**15-1].each do |i|
@@ -314,7 +314,7 @@ shared_examples_for 'a binary protocol' do
       @prot.read_i16.should == i
     end
   end
-  
+
   it "should read an i32" do
     # try a scattering of values, including min/max
     [-2**31, -235125, -6236, 0, 2351, 123123, 2**31-1].each do |i|
@@ -322,7 +322,7 @@ shared_examples_for 'a binary protocol' do
       @prot.read_i32.should == i
     end
   end
-  
+
   it "should read an i64" do
     # try a scattering of values, including min/max
     [-2**63, -123512312, -6346, 0, 32, 2346322323, 2**63-1].each do |i|
@@ -330,7 +330,7 @@ shared_examples_for 'a binary protocol' do
       @prot.read_i64.should == i
     end
   end
-  
+
   it "should read a double" do
     # try a random scattering of values, including min/max
     [Float::MIN, -231231.12351, -323.233513, 0, 123.2351235, 2351235.12351235, Float::MAX].each do |f|
@@ -383,23 +383,20 @@ shared_examples_for 'a binary protocol' do
 
   it "should perform a complete rpc with no args or return" do
     srv_test(
-      proc {|client| client.send_voidMethod()},
-      proc {|client| client.recv_voidMethod.should == nil}
+      proc {|client| client.voidMethod().should == nil },
     )
   end
 
   it "should perform a complete rpc with a primitive return type" do
     srv_test(
-      proc {|client| client.send_primitiveMethod()},
-      proc {|client| client.recv_primitiveMethod.should == 1}
+      proc {|client| client.primitiveMethod.should == 1}
     )
   end
 
   it "should perform a complete rpc with a struct return type" do
     srv_test(
-      proc {|client| client.send_structMethod()},
       proc {|client|
-        result = client.recv_structMethod
+        result = client.structMethod
         result.set_byte_map = nil
         result.map_byte_map = nil
         result.should == Fixtures::COMPACT_PROTOCOL_TEST_STRUCT
@@ -410,14 +407,14 @@ shared_examples_for 'a binary protocol' do
   def get_socket_connection
     server = Thrift::ServerSocket.new("localhost", 9090)
     server.listen
-    
+
     clientside = Thrift::Socket.new("localhost", 9090)
     clientside.open
     serverside = server.accept
     [clientside, serverside, server]
   end
 
-  def srv_test(firstblock, secondblock)
+  def srv_test(block)
     clientside, serverside, server = get_socket_connection
 
     clientproto = protocol_class.new(clientside)
@@ -425,29 +422,29 @@ shared_examples_for 'a binary protocol' do
 
     processor = Srv::Processor.new(SrvHandler.new)
 
-    client = Srv::Client.new(clientproto, clientproto)
+    client = Srv::Client.new(clientproto)
+
+    t = Thread.new { processor.process(serverproto, serverproto) }
 
-    # first block
-    firstblock.call(client)
+    resp = block.call(client)
 
-    processor.process(serverproto, serverproto)
+    t.join
 
-    # second block
-    secondblock.call(client)
+    resp
   ensure
     clientside.close
     serverside.close
     server.close
   end
 
-  class SrvHandler 
+  class SrvHandler
     def voidMethod()
     end
-    
+
     def primitiveMethod
       1
     end
-    
+
     def structMethod
       Fixtures::COMPACT_PROTOCOL_TEST_STRUCT
     end

data/spec/client_spec.rb

@@ -37,7 +37,7 @@ describe 'Client' do
     end
 
     it "should send a test message" do
-      @prot.should_receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::CALL, 0)
+      @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)
@@ -66,7 +66,7 @@ describe 'Client' do
     end
 
     it "should receive a test message" do
-      @prot.should_receive(:read_message_begin).and_return [nil, Thrift::MessageTypes::CALL, 0]
+      @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)

data/spec/compact_protocol_spec.rb

@@ -31,14 +31,14 @@ describe Thrift::CompactProtocol do
     :double => [0.0, 1.0, -1.0, 1.1, -1.1, 10000000.1, 1.0/0.0, -1.0/0.0],
     :bool => [true, false]
   }
-  
+
   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
         trans = Thrift::MemoryBufferTransport.new
         proto = Thrift::CompactProtocol.new(trans)
-        
+
         proto.send(writer(primitive_type), value)
         # puts "buf: #{trans.inspect_buffer}" if primitive_type == :i64
         read_back = proto.send(reader(primitive_type))
@@ -46,7 +46,7 @@ describe Thrift::CompactProtocol do
       end
     end
   end
-  
+
   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
@@ -80,32 +80,38 @@ describe Thrift::CompactProtocol do
     struct.write(proto)
 
     struct2 = CompactProtoTestStruct.new
-    struct2.read(proto)    
+    struct2.read(proto)
     struct2.should == struct
   end
 
-  it "should make method calls correctly" do
-    client_out_trans = Thrift::MemoryBufferTransport.new
+  xit "should make method calls correctly" do
+    r1, w1 = IO.pipe
+    r2, w2 = IO.pipe
+    client_out_trans = Thrift::IOStreamTransport.new(r2, w1)
     client_out_proto = Thrift::CompactProtocol.new(client_out_trans)
 
-    client_in_trans = Thrift::MemoryBufferTransport.new
+    client_in_trans = Thrift::IOStreamTransport.new(r1, w2)
     client_in_proto = Thrift::CompactProtocol.new(client_in_trans)
 
     processor = Srv::Processor.new(JankyHandler.new)
 
-    client = Srv::Client.new(client_in_proto, client_out_proto)
-    client.send_Janky(1)
-    # puts client_out_trans.inspect_buffer
-    processor.process(client_out_proto, client_in_proto)
-    client.recv_Janky.should == 2
+    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
   end
-  
+
   it "should deal with fields following fields that have non-delta ids" do
     brcp = BreaksRubyCompactProtocol.new(
-      :field1 => "blah", 
+      :field1 => "blah",
       :field2 => BigFieldIdStruct.new(
-        :field1 => "string1", 
-        :field2 => "string2"), 
+        :field1 => "string1",
+        :field2 => "string2"),
       :field3 => 3)
     ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new)
     bytes = ser.serialize(brcp)
@@ -115,7 +121,7 @@ describe Thrift::CompactProtocol do
     deser.deserialize(brcp2, bytes)
     brcp2.should == brcp
   end
-  
+
   it "should deserialize an empty map to an empty hash" do
     struct = SingleMapTestStruct.new(:i32_map => {})
     ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new)
@@ -126,17 +132,17 @@ describe Thrift::CompactProtocol do
     deser.deserialize(struct2, bytes)
     struct.should == struct2
   end
-  
+
   class JankyHandler
     def Janky(i32arg)
       i32arg * 2
     end
   end
-  
+
   def writer(sym)
     "write_#{sym.to_s}"
   end
-  
+
   def reader(sym)
     "read_#{sym.to_s}"
   end

data/spec/http_client_spec.rb

@@ -23,7 +23,10 @@ describe 'Thrift::HTTPClientTransport' do
 
   describe Thrift::HTTPClientTransport do
     before(:each) do
-      @client = Thrift::HTTPClientTransport.new("http://my.domain.com/path/to/service?param=value")
+      @client = Thrift::HTTPClientTransport.new(
+        "http://my.domain.com/path/to/service?param=value",
+        retries: 0
+      )
     end
 
     it "should always be open" do
@@ -41,6 +44,7 @@ describe 'Thrift::HTTPClientTransport' do
           http.should_receive(:post).with("/path/to/service?param=value", "a test frame", {"Content-Type"=>"application/x-thrift"}).and_return do
             mock("Net::HTTPOK").tap do |response|
               response.should_receive(:body).and_return "data"
+              response.should_receive(:value).and_return nil
             end
           end
         end
@@ -48,25 +52,6 @@ describe 'Thrift::HTTPClientTransport' do
       @client.flush
       @client.read(10).should == "data"
     end
-
-    it "should send custom headers if defined" do
-      @client.write "test"
-      custom_headers = {"Cookie" => "Foo"}
-      headers = {"Content-Type"=>"application/x-thrift"}.merge(custom_headers)
-
-      @client.add_headers(custom_headers)
-      Net::HTTP.should_receive(:new).with("my.domain.com", 80).and_return do
-        mock("Net::HTTP").tap do |http|
-          http.should_receive(:use_ssl=).with(false)
-          http.should_receive(:post).with("/path/to/service?param=value", "test", headers).and_return do
-            mock("Net::HTTPOK").tap do |response|
-              response.should_receive(:body).and_return "data"
-            end
-          end
-        end
-      end
-      @client.flush
-    end
   end
 
   describe 'ssl enabled' do
@@ -88,6 +73,7 @@ describe 'Thrift::HTTPClientTransport' do
               "Content-Type" => "application/x-thrift").and_return do
             mock("Net::HTTPOK").tap do |response|
               response.should_receive(:body).and_return "data"
+              response.should_receive(:value).and_return nil
             end
           end
         end
@@ -109,6 +95,7 @@ describe 'Thrift::HTTPClientTransport' do
               "Content-Type" => "application/x-thrift").and_return do
             mock("Net::HTTPOK").tap do |response|
               response.should_receive(:body).and_return "data"
+              response.should_receive(:value).and_return nil
             end
           end
         end

data/spec/nonblocking_server_spec.rb

@@ -157,7 +157,7 @@ describe 'NonblockingServer' do
             when :hello
               result << client.greeting(true) # ignore result
             when :sleep
-              client.sleep(args[0] || 0.5)
+              client.sleep(args[0].to_f || 0.5)
               result << :slept
             when :shutdown
               client.shutdown

data/spec/processor_spec.rb

@@ -45,7 +45,7 @@ describe 'Processor' do
       @processor.process(@prot, @prot).should == true
     end
 
-    it "should raise an ApplicationException when the received message cannot be processed" do
+    xit "should raise an ApplicationException when the received message cannot be processed" do
       @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 4]
       @prot.should_receive(:skip).with(Thrift::Types::STRUCT).ordered
       @prot.should_receive(:read_message_end).ordered

data/spec/struct_spec.rb

@@ -227,7 +227,7 @@ describe 'Struct' do
     it "should support optional type-checking in Thrift::Struct.new" do
       Thrift.type_checking = true
       begin
-        lambda { SpecNamespace::Hello.new(:greeting => 3) }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Fixnum for field greeting")
+        lambda { SpecNamespace::Hello.new(:greeting => 3) }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Integer for field greeting")
       ensure
         Thrift.type_checking = false
       end
@@ -238,7 +238,7 @@ describe 'Struct' do
       Thrift.type_checking = true
       begin
         hello = SpecNamespace::Hello.new
-        lambda { hello.greeting = 3 }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Fixnum for field greeting")
+        lambda { hello.greeting = 3 }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Integer for field greeting")
       ensure
         Thrift.type_checking = false
       end

data/spec/types/known/any_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'thrift/types/value'
+require 'thrift/types/known/any'
+
+describe 'Thrift::Types::Known::Any' do
+  describe 'encode' do
+    let(:codec) { '' }
+
+    shared_examples 'idempotent' do
+      it 'should be idempotent' do
+        Thrift::Types::Known::Any.from_object(obj, codec).to_object.should == obj
+      end
+    end
+
+    subject { Thrift::Types::Known::Any.from_object(obj, codec) }
+
+    context 'thrift struct' do
+      let(:obj) { Thrift::Types::Value.from_object("foo") }
+
+      it { subject.type.should == 'thrift/types.value.Value' }
+      it { subject.value.should == '{"2":{"str":"foo"}}' }
+
+      include_examples 'idempotent'
+
+      context 'yaml only' do
+        let(:codec) { 'yaml' }
+
+        it { subject.type.should == 'thrift-yaml/types.value.Value' }
+        it { subject.value.should == "string_value: foo\n" }
+
+        include_examples 'idempotent'
+      end
+
+      context 'json only' do
+        let(:codec) { 'json' }
+
+        it { subject.type.should == 'thrift-json/types.value.Value' }
+        it { subject.value.should == '{"string_value":"foo"}' }
+
+        include_examples 'idempotent'
+      end
+    end
+  end
+end

data/spec/types/known/duration_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'thrift/types/known/duration'
+
+describe 'Thrift::Types::Known::Duration' do
+  context 'from_number' do
+    it 'from float' do
+      d = Thrift::Types::Known::Duration.from_number(2.0005)
+
+      d.seconds.should == 2
+      d.nanos.should == 500_000
+    end
+
+    it 'from int' do
+      d = Thrift::Types::Known::Duration.from_number(127)
+
+      d.seconds.should == 127
+      d.nanos.should == 0
+    end
+  end
+end

data/spec/types/known/timestamp_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'thrift/types/known/timestamp'
+
+describe 'Thrift::Types::Known::Timestamp' do
+  context 'from_time' do
+    it do
+      t = Time.at(137, 5, :nsec)
+
+      tt = Thrift::Types::Known::Timestamp.from_time(t)
+
+      tt.seconds.should == 137
+      tt.nanos.should == 5
+
+      tt.to_time.should == t
+    end
+  end
+end