thrift 0.11.0.0 → 0.14.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (82) hide show
  1. checksums.yaml +5 -5
  2. data/lib/thrift/protocol/base_protocol.rb +11 -3
  3. data/lib/thrift/protocol/binary_protocol.rb +8 -1
  4. data/lib/thrift/protocol/binary_protocol_accelerated.rb +8 -0
  5. data/lib/thrift/protocol/compact_protocol.rb +8 -0
  6. data/lib/thrift/protocol/json_protocol.rb +8 -0
  7. data/lib/thrift/protocol/multiplexed_protocol.rb +5 -1
  8. data/lib/thrift/server/base_server.rb +8 -2
  9. data/lib/thrift/server/simple_server.rb +5 -1
  10. data/lib/thrift/server/thread_pool_server.rb +5 -1
  11. data/lib/thrift/server/threaded_server.rb +5 -1
  12. data/lib/thrift/transport/base_server_transport.rb +1 -1
  13. data/lib/thrift/transport/base_transport.rb +8 -0
  14. data/lib/thrift/transport/buffered_transport.rb +9 -1
  15. data/lib/thrift/transport/framed_transport.rb +9 -1
  16. data/lib/thrift/transport/http_client_transport.rb +6 -0
  17. data/lib/thrift/transport/io_stream_transport.rb +4 -1
  18. data/lib/thrift/transport/memory_buffer_transport.rb +4 -0
  19. data/lib/thrift/transport/server_socket.rb +6 -1
  20. data/lib/thrift/transport/socket.rb +4 -2
  21. data/lib/thrift/transport/ssl_server_socket.rb +4 -0
  22. data/lib/thrift/transport/ssl_socket.rb +4 -0
  23. data/lib/thrift/transport/unix_server_socket.rb +5 -1
  24. data/lib/thrift/transport/unix_socket.rb +5 -1
  25. data/spec/base_protocol_spec.rb +79 -71
  26. data/spec/base_transport_spec.rb +155 -117
  27. data/spec/binary_protocol_accelerated_spec.rb +6 -2
  28. data/spec/binary_protocol_spec.rb +16 -8
  29. data/spec/binary_protocol_spec_shared.rb +73 -70
  30. data/spec/bytes_spec.rb +38 -38
  31. data/spec/client_spec.rb +41 -42
  32. data/spec/compact_protocol_spec.rb +23 -8
  33. data/spec/exception_spec.rb +54 -54
  34. data/spec/flat_spec.rb +5 -5
  35. data/spec/http_client_spec.rb +64 -38
  36. data/spec/json_protocol_spec.rb +146 -138
  37. data/spec/namespaced_spec.rb +5 -5
  38. data/spec/nonblocking_server_spec.rb +16 -16
  39. data/spec/processor_spec.rb +26 -26
  40. data/spec/serializer_spec.rb +20 -20
  41. data/spec/server_socket_spec.rb +27 -22
  42. data/spec/server_spec.rb +91 -52
  43. data/spec/socket_spec.rb +23 -16
  44. data/spec/socket_spec_shared.rb +31 -31
  45. data/spec/ssl_server_socket_spec.rb +34 -0
  46. data/spec/ssl_socket_spec.rb +26 -22
  47. data/spec/struct_nested_containers_spec.rb +24 -24
  48. data/spec/struct_spec.rb +120 -120
  49. data/spec/thin_http_server_spec.rb +18 -18
  50. data/spec/types_spec.rb +56 -53
  51. data/spec/union_spec.rb +42 -43
  52. data/spec/unix_socket_spec.rb +43 -34
  53. metadata +138 -158
  54. data/benchmark/gen-rb/benchmark_constants.rb +0 -11
  55. data/benchmark/gen-rb/benchmark_service.rb +0 -80
  56. data/benchmark/gen-rb/benchmark_types.rb +0 -10
  57. data/spec/gen-rb/base/base_service.rb +0 -80
  58. data/spec/gen-rb/base/base_service_constants.rb +0 -11
  59. data/spec/gen-rb/base/base_service_types.rb +0 -26
  60. data/spec/gen-rb/extended/extended_service.rb +0 -78
  61. data/spec/gen-rb/extended/extended_service_constants.rb +0 -11
  62. data/spec/gen-rb/extended/extended_service_types.rb +0 -12
  63. data/spec/gen-rb/flat/namespaced_nonblocking_service.rb +0 -272
  64. data/spec/gen-rb/flat/referenced_constants.rb +0 -11
  65. data/spec/gen-rb/flat/referenced_types.rb +0 -17
  66. data/spec/gen-rb/flat/thrift_namespaced_spec_constants.rb +0 -11
  67. data/spec/gen-rb/flat/thrift_namespaced_spec_types.rb +0 -28
  68. data/spec/gen-rb/namespaced_spec_namespace/namespaced_nonblocking_service.rb +0 -272
  69. data/spec/gen-rb/namespaced_spec_namespace/thrift_namespaced_spec_constants.rb +0 -11
  70. data/spec/gen-rb/namespaced_spec_namespace/thrift_namespaced_spec_types.rb +0 -28
  71. data/spec/gen-rb/nonblocking_service.rb +0 -272
  72. data/spec/gen-rb/other_namespace/referenced_constants.rb +0 -11
  73. data/spec/gen-rb/other_namespace/referenced_types.rb +0 -17
  74. data/spec/gen-rb/thrift_spec_constants.rb +0 -11
  75. data/spec/gen-rb/thrift_spec_types.rb +0 -538
  76. data/test/debug_proto/gen-rb/debug_proto_test_constants.rb +0 -278
  77. data/test/debug_proto/gen-rb/debug_proto_test_types.rb +0 -781
  78. data/test/debug_proto/gen-rb/empty_service.rb +0 -28
  79. data/test/debug_proto/gen-rb/inherited.rb +0 -83
  80. data/test/debug_proto/gen-rb/reverse_order_service.rb +0 -86
  81. data/test/debug_proto/gen-rb/service_for_exception_with_a_map.rb +0 -85
  82. data/test/debug_proto/gen-rb/srv.rb +0 -395
@@ -32,7 +32,7 @@ describe 'namespaced generation' do
32
32
  "other_namespace/referenced_constants.rb",
33
33
  "other_namespace/referenced_types.rb"
34
34
  ].each do |name|
35
- File.exist?(File.join(prefix, name)).should be_true
35
+ expect(File.exist?(File.join(prefix, name))).to be_truthy
36
36
  end
37
37
  end
38
38
 
@@ -44,20 +44,20 @@ describe 'namespaced generation' do
44
44
  "referenced_constants.rb",
45
45
  "referenced_types.rb"
46
46
  ].each do |name|
47
- File.exist?(File.join(prefix, name)).should_not be_true
47
+ expect(File.exist?(File.join(prefix, name))).not_to be_truthy
48
48
  end
49
49
  end
50
50
 
51
51
  it "has a service class in the right place" do
52
- defined?(NamespacedSpecNamespace::NamespacedNonblockingService).should be_true
52
+ expect(defined?(NamespacedSpecNamespace::NamespacedNonblockingService)).to be_truthy
53
53
  end
54
54
 
55
55
  it "has a struct in the right place" do
56
- defined?(NamespacedSpecNamespace::Hello).should be_true
56
+ expect(defined?(NamespacedSpecNamespace::Hello)).to be_truthy
57
57
  end
58
58
 
59
59
  it "required an included file" do
60
- defined?(OtherNamespace::SomeEnum).should be_true
60
+ expect(defined?(OtherNamespace::SomeEnum)).to be_truthy
61
61
  end
62
62
 
63
63
  it "extended a service" do
@@ -176,8 +176,8 @@ describe 'NonblockingServer' do
176
176
 
177
177
  it "should handle basic message passing" do
178
178
  client = setup_client
179
- client.greeting(true).should == SpecNamespace::Hello.new
180
- client.greeting(false).should == SpecNamespace::Hello.new(:greeting => 'Aloha!')
179
+ expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
180
+ expect(client.greeting(false)).to eq(SpecNamespace::Hello.new(:greeting => 'Aloha!'))
181
181
  @server.shutdown
182
182
  end
183
183
 
@@ -195,7 +195,7 @@ describe 'NonblockingServer' do
195
195
  end
196
196
  4.times { trans_queue.pop }
197
197
  setup_client.unblock(4)
198
- 4.times { queue.pop.should be_true }
198
+ 4.times { expect(queue.pop).to be_truthy }
199
199
  @server.shutdown
200
200
  end
201
201
 
@@ -212,15 +212,15 @@ describe 'NonblockingServer' do
212
212
  queues[4] << :hello
213
213
  queues[5] << :hello
214
214
  queues[6] << :hello
215
- 3.times { result.pop.should == SpecNamespace::Hello.new }
216
- client.greeting(true).should == SpecNamespace::Hello.new
215
+ 3.times { expect(result.pop).to eq(SpecNamespace::Hello.new) }
216
+ expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
217
217
  queues[5] << [:unblock, 4]
218
- 4.times { result.pop.should be_true }
218
+ 4.times { expect(result.pop).to be_truthy }
219
219
  queues[2] << :hello
220
- result.pop.should == SpecNamespace::Hello.new
221
- client.greeting(false).should == SpecNamespace::Hello.new(:greeting => 'Aloha!')
220
+ expect(result.pop).to eq(SpecNamespace::Hello.new)
221
+ expect(client.greeting(false)).to eq(SpecNamespace::Hello.new(:greeting => 'Aloha!'))
222
222
  7.times { queues.shift << :exit }
223
- client.greeting(true).should == SpecNamespace::Hello.new
223
+ expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
224
224
  @server.shutdown
225
225
  end
226
226
 
@@ -229,7 +229,7 @@ describe 'NonblockingServer' do
229
229
  client = setup_client
230
230
  client.greeting(false) # force a message pass
231
231
  @server.shutdown
232
- @server_thread.join(2).should be_an_instance_of(Thread)
232
+ expect(@server_thread.join(2)).to be_an_instance_of(Thread)
233
233
  end
234
234
 
235
235
  it "should continue processing active messages when shutting down" do
@@ -238,8 +238,8 @@ describe 'NonblockingServer' do
238
238
  client << :sleep
239
239
  sleep 0.1 # give the server time to start processing the client's message
240
240
  @server.shutdown
241
- @server_thread.join(2).should be_an_instance_of(Thread)
242
- result.pop.should == :slept
241
+ expect(@server_thread.join(2)).to be_an_instance_of(Thread)
242
+ expect(result.pop).to eq(:slept)
243
243
  end
244
244
 
245
245
  it "should kill active messages when they don't expire while shutting down" do
@@ -249,15 +249,15 @@ describe 'NonblockingServer' do
249
249
  sleep 0.1 # start processing the client's message
250
250
  @server.shutdown(1)
251
251
  @catch_exceptions = true
252
- @server_thread.join(3).should_not be_nil
253
- result.should be_empty
252
+ expect(@server_thread.join(3)).not_to be_nil
253
+ expect(result).to be_empty
254
254
  end
255
255
 
256
256
  it "should allow shutting down in response to a message" do
257
257
  client = setup_client
258
- client.greeting(true).should == SpecNamespace::Hello.new
258
+ expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
259
259
  client.shutdown
260
- @server_thread.join(2).should_not be_nil
260
+ expect(@server_thread.join(2)).not_to be_nil
261
261
  end
262
262
  end
263
263
  end
@@ -27,52 +27,52 @@ describe 'Processor' do
27
27
 
28
28
  describe Thrift::Processor do
29
29
  before(:each) do
30
- @processor = ProcessorSpec.new(mock("MockHandler"))
31
- @prot = mock("MockProtocol")
30
+ @processor = ProcessorSpec.new(double("MockHandler"))
31
+ @prot = double("MockProtocol")
32
32
  end
33
33
 
34
34
  def mock_trans(obj)
35
- obj.should_receive(:trans).ordered.and_return do
36
- mock("trans").tap do |trans|
37
- trans.should_receive(:flush).ordered
35
+ expect(obj).to receive(:trans).ordered do
36
+ double("trans").tap do |trans|
37
+ expect(trans).to receive(:flush).ordered
38
38
  end
39
39
  end
40
40
  end
41
41
 
42
42
  it "should call process_<message> when it receives that message" do
43
- @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 17]
44
- @processor.should_receive(:process_testMessage).with(17, @prot, @prot).ordered
45
- @processor.process(@prot, @prot).should == true
43
+ expect(@prot).to receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 17]
44
+ expect(@processor).to receive(:process_testMessage).with(17, @prot, @prot).ordered
45
+ expect(@processor.process(@prot, @prot)).to eq(true)
46
46
  end
47
47
 
48
48
  it "should raise an ApplicationException when the received message cannot be processed" do
49
- @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 4]
50
- @prot.should_receive(:skip).with(Thrift::Types::STRUCT).ordered
51
- @prot.should_receive(:read_message_end).ordered
52
- @prot.should_receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::EXCEPTION, 4).ordered
53
- e = mock(Thrift::ApplicationException)
54
- e.should_receive(:write).with(@prot).ordered
55
- Thrift::ApplicationException.should_receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return(e)
56
- @prot.should_receive(:write_message_end).ordered
49
+ expect(@prot).to receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 4]
50
+ expect(@prot).to receive(:skip).with(Thrift::Types::STRUCT).ordered
51
+ expect(@prot).to receive(:read_message_end).ordered
52
+ expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::EXCEPTION, 4).ordered
53
+ e = double(Thrift::ApplicationException)
54
+ expect(e).to receive(:write).with(@prot).ordered
55
+ expect(Thrift::ApplicationException).to receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return(e)
56
+ expect(@prot).to receive(:write_message_end).ordered
57
57
  mock_trans(@prot)
58
58
  @processor.process(@prot, @prot)
59
59
  end
60
60
 
61
61
  it "should pass args off to the args class" do
62
- args_class = mock("MockArgsClass")
63
- args = mock("#<MockArgsClass:mock>").tap do |args|
64
- args.should_receive(:read).with(@prot).ordered
62
+ args_class = double("MockArgsClass")
63
+ args = double("#<MockArgsClass:mock>").tap do |args|
64
+ expect(args).to receive(:read).with(@prot).ordered
65
65
  end
66
- args_class.should_receive(:new).and_return args
67
- @prot.should_receive(:read_message_end).ordered
68
- @processor.read_args(@prot, args_class).should eql(args)
66
+ expect(args_class).to receive(:new).and_return args
67
+ expect(@prot).to receive(:read_message_end).ordered
68
+ expect(@processor.read_args(@prot, args_class)).to eql(args)
69
69
  end
70
70
 
71
71
  it "should write out a reply when asked" do
72
- @prot.should_receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::REPLY, 23).ordered
73
- result = mock("MockResult")
74
- result.should_receive(:write).with(@prot).ordered
75
- @prot.should_receive(:write_message_end).ordered
72
+ expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::REPLY, 23).ordered
73
+ result = double("MockResult")
74
+ expect(result).to receive(:write).with(@prot).ordered
75
+ expect(@prot).to receive(:write_message_end).ordered
76
76
  mock_trans(@prot)
77
77
  @processor.write_result(result, @prot, 'testMessage', 23)
78
78
  end
@@ -25,19 +25,19 @@ describe 'Serializer' do
25
25
  it "should serialize structs to binary by default" do
26
26
  serializer = Thrift::Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)
27
27
  data = serializer.serialize(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
28
- data.should == "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
28
+ expect(data).to eq("\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00")
29
29
  end
30
30
 
31
31
  it "should serialize structs to the given protocol" do
32
- protocol = Thrift::BaseProtocol.new(mock("transport"))
33
- protocol.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
34
- protocol.should_receive(:write_field_begin).with("greeting", Thrift::Types::STRING, 1)
35
- protocol.should_receive(:write_string).with("Good day")
36
- protocol.should_receive(:write_field_end)
37
- protocol.should_receive(:write_field_stop)
38
- protocol.should_receive(:write_struct_end)
39
- protocol_factory = mock("ProtocolFactory")
40
- protocol_factory.stub!(:get_protocol).and_return(protocol)
32
+ protocol = Thrift::BaseProtocol.new(double("transport"))
33
+ expect(protocol).to receive(:write_struct_begin).with("SpecNamespace::Hello")
34
+ expect(protocol).to receive(:write_field_begin).with("greeting", Thrift::Types::STRING, 1)
35
+ expect(protocol).to receive(:write_string).with("Good day")
36
+ expect(protocol).to receive(:write_field_end)
37
+ expect(protocol).to receive(:write_field_stop)
38
+ expect(protocol).to receive(:write_struct_end)
39
+ protocol_factory = double("ProtocolFactory")
40
+ allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
41
41
  serializer = Thrift::Serializer.new(protocol_factory)
42
42
  serializer.serialize(SpecNamespace::Hello.new(:greeting => "Good day"))
43
43
  end
@@ -47,21 +47,21 @@ describe 'Serializer' do
47
47
  it "should deserialize structs from binary by default" do
48
48
  deserializer = Thrift::Deserializer.new
49
49
  data = "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
50
- deserializer.deserialize(SpecNamespace::Hello.new, data).should == SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!")
50
+ expect(deserializer.deserialize(SpecNamespace::Hello.new, data)).to eq(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
51
51
  end
52
52
 
53
53
  it "should deserialize structs from the given protocol" do
54
- protocol = Thrift::BaseProtocol.new(mock("transport"))
55
- protocol.should_receive(:read_struct_begin).and_return("SpecNamespace::Hello")
56
- protocol.should_receive(:read_field_begin).and_return(["greeting", Thrift::Types::STRING, 1],
54
+ protocol = Thrift::BaseProtocol.new(double("transport"))
55
+ expect(protocol).to receive(:read_struct_begin).and_return("SpecNamespace::Hello")
56
+ expect(protocol).to receive(:read_field_begin).and_return(["greeting", Thrift::Types::STRING, 1],
57
57
  [nil, Thrift::Types::STOP, 0])
58
- protocol.should_receive(:read_string).and_return("Good day")
59
- protocol.should_receive(:read_field_end)
60
- protocol.should_receive(:read_struct_end)
61
- protocol_factory = mock("ProtocolFactory")
62
- protocol_factory.stub!(:get_protocol).and_return(protocol)
58
+ expect(protocol).to receive(:read_string).and_return("Good day")
59
+ expect(protocol).to receive(:read_field_end)
60
+ expect(protocol).to receive(:read_struct_end)
61
+ protocol_factory = double("ProtocolFactory")
62
+ allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
63
63
  deserializer = Thrift::Deserializer.new(protocol_factory)
64
- deserializer.deserialize(SpecNamespace::Hello.new, "").should == SpecNamespace::Hello.new(:greeting => "Good day")
64
+ expect(deserializer.deserialize(SpecNamespace::Hello.new, "")).to eq(SpecNamespace::Hello.new(:greeting => "Good day"))
65
65
  end
66
66
  end
67
67
  end
@@ -28,52 +28,57 @@ describe 'Thrift::ServerSocket' do
28
28
  end
29
29
 
30
30
  it "should create a handle when calling listen" do
31
- TCPServer.should_receive(:new).with(nil, 1234)
31
+ expect(TCPServer).to receive(:new).with(nil, 1234)
32
32
  @socket.listen
33
33
  end
34
34
 
35
35
  it "should accept an optional host argument" do
36
36
  @socket = Thrift::ServerSocket.new('localhost', 1234)
37
- TCPServer.should_receive(:new).with('localhost', 1234)
37
+ expect(TCPServer).to receive(:new).with('localhost', 1234)
38
+ @socket.to_s == "server(localhost:1234)"
38
39
  @socket.listen
39
40
  end
40
41
 
41
42
  it "should create a Thrift::Socket to wrap accepted sockets" do
42
- handle = mock("TCPServer")
43
- TCPServer.should_receive(:new).with(nil, 1234).and_return(handle)
43
+ handle = double("TCPServer")
44
+ expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
44
45
  @socket.listen
45
- sock = mock("sock")
46
- handle.should_receive(:accept).and_return(sock)
47
- trans = mock("Socket")
48
- Thrift::Socket.should_receive(:new).and_return(trans)
49
- trans.should_receive(:handle=).with(sock)
50
- @socket.accept.should == trans
46
+ sock = double("sock")
47
+ expect(handle).to receive(:accept).and_return(sock)
48
+ trans = double("Socket")
49
+ expect(Thrift::Socket).to receive(:new).and_return(trans)
50
+ expect(trans).to receive(:handle=).with(sock)
51
+ expect(@socket.accept).to eq(trans)
51
52
  end
52
53
 
53
54
  it "should close the handle when closed" do
54
- handle = mock("TCPServer", :closed? => false)
55
- TCPServer.should_receive(:new).with(nil, 1234).and_return(handle)
55
+ handle = double("TCPServer", :closed? => false)
56
+ expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
56
57
  @socket.listen
57
- handle.should_receive(:close)
58
+ expect(handle).to receive(:close)
58
59
  @socket.close
59
60
  end
60
61
 
61
62
  it "should return nil when accepting if there is no handle" do
62
- @socket.accept.should be_nil
63
+ expect(@socket.accept).to be_nil
63
64
  end
64
65
 
65
66
  it "should return true for closed? when appropriate" do
66
- handle = mock("TCPServer", :closed? => false)
67
- TCPServer.stub!(:new).and_return(handle)
67
+ handle = double("TCPServer", :closed? => false)
68
+ allow(TCPServer).to receive(:new).and_return(handle)
68
69
  @socket.listen
69
- @socket.should_not be_closed
70
- handle.stub!(:close)
70
+ expect(@socket).not_to be_closed
71
+ allow(handle).to receive(:close)
71
72
  @socket.close
72
- @socket.should be_closed
73
+ expect(@socket).to be_closed
73
74
  @socket.listen
74
- @socket.should_not be_closed
75
- handle.stub!(:closed?).and_return(true)
76
- @socket.should be_closed
75
+ expect(@socket).not_to be_closed
76
+ allow(handle).to receive(:closed?).and_return(true)
77
+ expect(@socket).to be_closed
78
+ end
79
+
80
+ it "should provide a reasonable to_s" do
81
+ expect(@socket.to_s).to eq("socket(:1234)")
77
82
  end
78
83
  end
79
84
  end
data/spec/server_spec.rb CHANGED
@@ -21,96 +21,135 @@ require 'spec_helper'
21
21
  describe 'Server' do
22
22
 
23
23
  describe Thrift::BaseServer do
24
+ before(:each) do
25
+ @processor = double("Processor")
26
+ @serverTrans = double("ServerTransport")
27
+ @trans = double("BaseTransport")
28
+ @prot = double("BaseProtocol")
29
+ @server = described_class.new(@processor, @serverTrans, @trans, @prot)
30
+ end
31
+
24
32
  it "should default to BaseTransportFactory and BinaryProtocolFactory when not specified" do
25
- server = Thrift::BaseServer.new(mock("Processor"), mock("BaseServerTransport"))
26
- server.instance_variable_get(:'@transport_factory').should be_an_instance_of(Thrift::BaseTransportFactory)
27
- server.instance_variable_get(:'@protocol_factory').should be_an_instance_of(Thrift::BinaryProtocolFactory)
33
+ @server = Thrift::BaseServer.new(double("Processor"), double("BaseServerTransport"))
34
+ expect(@server.instance_variable_get(:'@transport_factory')).to be_an_instance_of(Thrift::BaseTransportFactory)
35
+ expect(@server.instance_variable_get(:'@protocol_factory')).to be_an_instance_of(Thrift::BinaryProtocolFactory)
28
36
  end
29
37
 
30
- # serve is a noop, so can't test that
38
+ it "should not serve" do
39
+ expect { @server.serve()}.to raise_error(NotImplementedError)
40
+ end
41
+
42
+ it "should provide a reasonable to_s" do
43
+ expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
44
+ expect(@trans).to receive(:to_s).once.and_return("trans")
45
+ expect(@prot).to receive(:to_s).once.and_return("prot")
46
+ expect(@server.to_s).to eq("server(prot(trans(serverTrans)))")
47
+ end
31
48
  end
32
49
 
33
50
  describe Thrift::SimpleServer do
34
51
  before(:each) do
35
- @processor = mock("Processor")
36
- @serverTrans = mock("ServerTransport")
37
- @trans = mock("BaseTransport")
38
- @prot = mock("BaseProtocol")
39
- @client = mock("Client")
52
+ @processor = double("Processor")
53
+ @serverTrans = double("ServerTransport")
54
+ @trans = double("BaseTransport")
55
+ @prot = double("BaseProtocol")
56
+ @client = double("Client")
40
57
  @server = described_class.new(@processor, @serverTrans, @trans, @prot)
41
58
  end
42
59
 
60
+ it "should provide a reasonable to_s" do
61
+ expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
62
+ expect(@trans).to receive(:to_s).once.and_return("trans")
63
+ expect(@prot).to receive(:to_s).once.and_return("prot")
64
+ expect(@server.to_s).to eq("simple(server(prot(trans(serverTrans))))")
65
+ end
66
+
43
67
  it "should serve in the main thread" do
44
- @serverTrans.should_receive(:listen).ordered
45
- @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
46
- @trans.should_receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
47
- @prot.should_receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
68
+ expect(@serverTrans).to receive(:listen).ordered
69
+ expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
70
+ expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
71
+ expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
48
72
  x = 0
49
- @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
73
+ expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
50
74
  case (x += 1)
51
75
  when 1 then raise Thrift::TransportException
52
76
  when 2 then raise Thrift::ProtocolException
53
77
  when 3 then throw :stop
54
78
  end
55
79
  end
56
- @trans.should_receive(:close).exactly(3).times
57
- @serverTrans.should_receive(:close).ordered
58
- lambda { @server.serve }.should throw_symbol(:stop)
80
+ expect(@trans).to receive(:close).exactly(3).times
81
+ expect(@serverTrans).to receive(:close).ordered
82
+ expect { @server.serve }.to throw_symbol(:stop)
59
83
  end
60
84
  end
61
85
 
62
86
  describe Thrift::ThreadedServer do
63
87
  before(:each) do
64
- @processor = mock("Processor")
65
- @serverTrans = mock("ServerTransport")
66
- @trans = mock("BaseTransport")
67
- @prot = mock("BaseProtocol")
68
- @client = mock("Client")
88
+ @processor = double("Processor")
89
+ @serverTrans = double("ServerTransport")
90
+ @trans = double("BaseTransport")
91
+ @prot = double("BaseProtocol")
92
+ @client = double("Client")
69
93
  @server = described_class.new(@processor, @serverTrans, @trans, @prot)
70
94
  end
71
95
 
96
+ it "should provide a reasonable to_s" do
97
+ expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
98
+ expect(@trans).to receive(:to_s).once.and_return("trans")
99
+ expect(@prot).to receive(:to_s).once.and_return("prot")
100
+ expect(@server.to_s).to eq("threaded(server(prot(trans(serverTrans))))")
101
+ end
102
+
72
103
  it "should serve using threads" do
73
- @serverTrans.should_receive(:listen).ordered
74
- @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
75
- @trans.should_receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
76
- @prot.should_receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
77
- Thread.should_receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
104
+ expect(@serverTrans).to receive(:listen).ordered
105
+ expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
106
+ expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
107
+ expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
108
+ expect(Thread).to receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
78
109
  x = 0
79
- @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
110
+ expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
80
111
  case (x += 1)
81
112
  when 1 then raise Thrift::TransportException
82
113
  when 2 then raise Thrift::ProtocolException
83
114
  when 3 then throw :stop
84
115
  end
85
116
  end
86
- @trans.should_receive(:close).exactly(3).times
87
- @serverTrans.should_receive(:close).ordered
88
- lambda { @server.serve }.should throw_symbol(:stop)
117
+ expect(@trans).to receive(:close).exactly(3).times
118
+ expect(@serverTrans).to receive(:close).ordered
119
+ expect { @server.serve }.to throw_symbol(:stop)
89
120
  end
90
121
  end
91
122
 
92
123
  describe Thrift::ThreadPoolServer do
93
124
  before(:each) do
94
- @processor = mock("Processor")
95
- @server_trans = mock("ServerTransport")
96
- @trans = mock("BaseTransport")
97
- @prot = mock("BaseProtocol")
98
- @client = mock("Client")
125
+ @processor = double("Processor")
126
+ @server_trans = double("ServerTransport")
127
+ @trans = double("BaseTransport")
128
+ @prot = double("BaseProtocol")
129
+ @client = double("Client")
99
130
  @server = described_class.new(@processor, @server_trans, @trans, @prot)
100
- sleep(0.1)
131
+ sleep(0.15)
101
132
  end
102
133
 
134
+ it "should provide a reasonable to_s" do
135
+ expect(@server_trans).to receive(:to_s).once.and_return("server_trans")
136
+ expect(@trans).to receive(:to_s).once.and_return("trans")
137
+ expect(@prot).to receive(:to_s).once.and_return("prot")
138
+ expect(@server.to_s).to eq("threadpool(server(prot(trans(server_trans))))")
139
+ end
140
+
103
141
  it "should serve inside a thread" do
104
142
  exception_q = @server.instance_variable_get(:@exception_q)
105
- described_class.any_instance.should_receive(:serve) do
143
+ expect_any_instance_of(described_class).to receive(:serve) do
106
144
  exception_q.push(StandardError.new('ERROR'))
107
145
  end
108
146
  expect { @server.rescuable_serve }.to(raise_error('ERROR'))
147
+ sleep(0.15)
109
148
  end
110
149
 
111
150
  it "should avoid running the server twice when retrying rescuable_serve" do
112
151
  exception_q = @server.instance_variable_get(:@exception_q)
113
- described_class.any_instance.should_receive(:serve) do
152
+ expect_any_instance_of(described_class).to receive(:serve) do
114
153
  exception_q.push(StandardError.new('ERROR1'))
115
154
  exception_q.push(StandardError.new('ERROR2'))
116
155
  end
@@ -119,29 +158,29 @@ describe 'Server' do
119
158
  end
120
159
 
121
160
  it "should serve using a thread pool" do
122
- thread_q = mock("SizedQueue")
123
- exception_q = mock("Queue")
161
+ thread_q = double("SizedQueue")
162
+ exception_q = double("Queue")
124
163
  @server.instance_variable_set(:@thread_q, thread_q)
125
164
  @server.instance_variable_set(:@exception_q, exception_q)
126
- @server_trans.should_receive(:listen).ordered
127
- thread_q.should_receive(:push).with(:token)
128
- thread_q.should_receive(:pop)
129
- Thread.should_receive(:new).and_yield
130
- @server_trans.should_receive(:accept).exactly(3).times.and_return(@client)
131
- @trans.should_receive(:get_transport).exactly(3).times.and_return(@trans)
132
- @prot.should_receive(:get_protocol).exactly(3).times.and_return(@prot)
165
+ expect(@server_trans).to receive(:listen).ordered
166
+ expect(thread_q).to receive(:push).with(:token)
167
+ expect(thread_q).to receive(:pop)
168
+ expect(Thread).to receive(:new).and_yield
169
+ expect(@server_trans).to receive(:accept).exactly(3).times.and_return(@client)
170
+ expect(@trans).to receive(:get_transport).exactly(3).times.and_return(@trans)
171
+ expect(@prot).to receive(:get_protocol).exactly(3).times.and_return(@prot)
133
172
  x = 0
134
173
  error = RuntimeError.new("Stopped")
135
- @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
174
+ expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
136
175
  case (x += 1)
137
176
  when 1 then raise Thrift::TransportException
138
177
  when 2 then raise Thrift::ProtocolException
139
178
  when 3 then raise error
140
179
  end
141
180
  end
142
- @trans.should_receive(:close).exactly(3).times
143
- exception_q.should_receive(:push).with(error).and_throw(:stop)
144
- @server_trans.should_receive(:close)
181
+ expect(@trans).to receive(:close).exactly(3).times
182
+ expect(exception_q).to receive(:push).with(error).and_throw(:stop)
183
+ expect(@server_trans).to receive(:close)
145
184
  expect { @server.serve }.to(throw_symbol(:stop))
146
185
  end
147
186
  end
data/spec/socket_spec.rb CHANGED
@@ -25,37 +25,44 @@ describe 'Socket' do
25
25
  describe Thrift::Socket do
26
26
  before(:each) do
27
27
  @socket = Thrift::Socket.new
28
- @handle = mock("Handle", :closed? => false)
29
- @handle.stub!(:close)
30
- @handle.stub!(:connect_nonblock)
31
- @handle.stub!(:setsockopt)
32
- ::Socket.stub!(:new).and_return(@handle)
28
+ @handle = double("Handle", :closed? => false)
29
+ allow(@handle).to receive(:close)
30
+ allow(@handle).to receive(:connect_nonblock)
31
+ allow(@handle).to receive(:setsockopt)
32
+ allow(::Socket).to receive(:new).and_return(@handle)
33
33
  end
34
34
 
35
35
  it_should_behave_like "a socket"
36
36
 
37
37
  it "should raise a TransportException when it cannot open a socket" do
38
- ::Socket.should_receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
39
- lambda { @socket.open }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
38
+ expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
39
+ expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
40
40
  end
41
41
 
42
42
  it "should open a ::Socket with default args" do
43
- ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true, :setsockopt => nil))
44
- ::Socket.should_receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
45
- ::Socket.should_receive(:sockaddr_in)
43
+ expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
44
+ expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
45
+ expect(::Socket).to receive(:sockaddr_in)
46
+ @socket.to_s == "socket(localhost:9090)"
46
47
  @socket.open
47
48
  end
48
49
 
49
50
  it "should accept host/port options" do
50
- ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true, :setsockopt => nil))
51
- ::Socket.should_receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
52
- ::Socket.should_receive(:sockaddr_in)
53
- Thrift::Socket.new('my.domain', 1234).open
51
+ expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
52
+ expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
53
+ expect(::Socket).to receive(:sockaddr_in)
54
+ @socket = Thrift::Socket.new('my.domain', 1234).open
55
+ @socket.to_s == "socket(my.domain:1234)"
54
56
  end
55
57
 
56
58
  it "should accept an optional timeout" do
57
- ::Socket.stub!(:new)
58
- Thrift::Socket.new('localhost', 8080, 5).timeout.should == 5
59
+ allow(::Socket).to receive(:new)
60
+ expect(Thrift::Socket.new('localhost', 8080, 5).timeout).to eq(5)
61
+ end
62
+
63
+ it "should provide a reasonable to_s" do
64
+ allow(::Socket).to receive(:new)
65
+ expect(Thrift::Socket.new('myhost', 8090).to_s).to eq("socket(myhost:8090)")
59
66
  end
60
67
  end
61
68
  end