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
@@ -24,105 +24,119 @@ describe 'BaseTransport' do
24
24
  describe Thrift::TransportException do
25
25
  it "should make type accessible" do
26
26
  exc = Thrift::TransportException.new(Thrift::TransportException::ALREADY_OPEN, "msg")
27
- exc.type.should == Thrift::TransportException::ALREADY_OPEN
28
- exc.message.should == "msg"
27
+ expect(exc.type).to eq(Thrift::TransportException::ALREADY_OPEN)
28
+ expect(exc.message).to eq("msg")
29
29
  end
30
30
  end
31
31
 
32
32
  describe Thrift::BaseTransport do
33
33
  it "should read the specified size" do
34
34
  transport = Thrift::BaseTransport.new
35
- transport.should_receive(:read).with(40).ordered.and_return("10 letters")
36
- transport.should_receive(:read).with(30).ordered.and_return("fifteen letters")
37
- transport.should_receive(:read).with(15).ordered.and_return("more characters")
38
- transport.read_all(40).should == "10 lettersfifteen lettersmore characters"
35
+ expect(transport).to receive(:read).with(40).ordered.and_return("10 letters")
36
+ expect(transport).to receive(:read).with(30).ordered.and_return("fifteen letters")
37
+ expect(transport).to receive(:read).with(15).ordered.and_return("more characters")
38
+ expect(transport.read_all(40)).to eq("10 lettersfifteen lettersmore characters")
39
39
  end
40
40
 
41
41
  it "should stub out the rest of the methods" do
42
42
  # can't test for stubbiness, so just make sure they're defined
43
43
  [:open?, :open, :close, :read, :write, :flush].each do |sym|
44
- Thrift::BaseTransport.method_defined?(sym).should be_true
44
+ expect(Thrift::BaseTransport.method_defined?(sym)).to be_truthy
45
45
  end
46
46
  end
47
47
 
48
48
  it "should alias << to write" do
49
- Thrift::BaseTransport.instance_method(:<<).should == Thrift::BaseTransport.instance_method(:write)
49
+ expect(Thrift::BaseTransport.instance_method(:<<)).to eq(Thrift::BaseTransport.instance_method(:write))
50
+ end
51
+
52
+ it "should provide a reasonable to_s" do
53
+ expect(Thrift::BaseTransport.new.to_s).to eq("base")
50
54
  end
51
55
  end
52
56
 
53
57
  describe Thrift::BaseServerTransport do
54
58
  it "should stub out its methods" do
55
59
  [:listen, :accept, :close].each do |sym|
56
- Thrift::BaseServerTransport.method_defined?(sym).should be_true
60
+ expect(Thrift::BaseServerTransport.method_defined?(sym)).to be_truthy
57
61
  end
58
62
  end
59
63
  end
60
64
 
61
65
  describe Thrift::BaseTransportFactory do
62
66
  it "should return the transport it's given" do
63
- transport = mock("Transport")
64
- Thrift::BaseTransportFactory.new.get_transport(transport).should eql(transport)
67
+ transport = double("Transport")
68
+ expect(Thrift::BaseTransportFactory.new.get_transport(transport)).to eql(transport)
69
+ end
70
+
71
+ it "should provide a reasonable to_s" do
72
+ expect(Thrift::BaseTransportFactory.new.to_s).to eq("base")
65
73
  end
66
74
  end
67
75
 
68
76
  describe Thrift::BufferedTransport do
77
+ it "should provide a to_s that describes the encapsulation" do
78
+ trans = double("Transport")
79
+ expect(trans).to receive(:to_s).and_return("mock")
80
+ expect(Thrift::BufferedTransport.new(trans).to_s).to eq("buffered(mock)")
81
+ end
82
+
69
83
  it "should pass through everything but write/flush/read" do
70
- trans = mock("Transport")
71
- trans.should_receive(:open?).ordered.and_return("+ open?")
72
- trans.should_receive(:open).ordered.and_return("+ open")
73
- trans.should_receive(:flush).ordered # from the close
74
- trans.should_receive(:close).ordered.and_return("+ close")
84
+ trans = double("Transport")
85
+ expect(trans).to receive(:open?).ordered.and_return("+ open?")
86
+ expect(trans).to receive(:open).ordered.and_return("+ open")
87
+ expect(trans).to receive(:flush).ordered # from the close
88
+ expect(trans).to receive(:close).ordered.and_return("+ close")
75
89
  btrans = Thrift::BufferedTransport.new(trans)
76
- btrans.open?.should == "+ open?"
77
- btrans.open.should == "+ open"
78
- btrans.close.should == "+ close"
90
+ expect(btrans.open?).to eq("+ open?")
91
+ expect(btrans.open).to eq("+ open")
92
+ expect(btrans.close).to eq("+ close")
79
93
  end
80
94
 
81
95
  it "should buffer reads in chunks of #{Thrift::BufferedTransport::DEFAULT_BUFFER}" do
82
- trans = mock("Transport")
83
- trans.should_receive(:read).with(Thrift::BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
96
+ trans = double("Transport")
97
+ expect(trans).to receive(:read).with(Thrift::BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
84
98
  btrans = Thrift::BufferedTransport.new(trans)
85
- btrans.read(6).should == "lorum "
86
- btrans.read(6).should == "ipsum "
87
- btrans.read(6).should == "dolor "
88
- btrans.read(6).should == "emet"
99
+ expect(btrans.read(6)).to eq("lorum ")
100
+ expect(btrans.read(6)).to eq("ipsum ")
101
+ expect(btrans.read(6)).to eq("dolor ")
102
+ expect(btrans.read(6)).to eq("emet")
89
103
  end
90
104
 
91
105
  it "should buffer writes and send them on flush" do
92
- trans = mock("Transport")
106
+ trans = double("Transport")
93
107
  btrans = Thrift::BufferedTransport.new(trans)
94
108
  btrans.write("one/")
95
109
  btrans.write("two/")
96
110
  btrans.write("three/")
97
- trans.should_receive(:write).with("one/two/three/").ordered
98
- trans.should_receive(:flush).ordered
111
+ expect(trans).to receive(:write).with("one/two/three/").ordered
112
+ expect(trans).to receive(:flush).ordered
99
113
  btrans.flush
100
114
  end
101
115
 
102
116
  it "should only send buffered data once" do
103
- trans = mock("Transport")
117
+ trans = double("Transport")
104
118
  btrans = Thrift::BufferedTransport.new(trans)
105
119
  btrans.write("one/")
106
120
  btrans.write("two/")
107
121
  btrans.write("three/")
108
- trans.should_receive(:write).with("one/two/three/")
109
- trans.stub!(:flush)
122
+ expect(trans).to receive(:write).with("one/two/three/")
123
+ allow(trans).to receive(:flush)
110
124
  btrans.flush
111
125
  # Nothing to flush with no data
112
126
  btrans.flush
113
127
  end
114
128
 
115
129
  it "should flush on close" do
116
- trans = mock("Transport")
117
- trans.should_receive(:close)
130
+ trans = double("Transport")
131
+ expect(trans).to receive(:close)
118
132
  btrans = Thrift::BufferedTransport.new(trans)
119
- btrans.should_receive(:flush)
133
+ expect(btrans).to receive(:flush)
120
134
  btrans.close
121
135
  end
122
136
 
123
137
  it "should not write to socket if there's no data" do
124
- trans = mock("Transport")
125
- trans.should_receive(:flush)
138
+ trans = double("Transport")
139
+ expect(trans).to receive(:flush)
126
140
  btrans = Thrift::BufferedTransport.new(trans)
127
141
  btrans.flush
128
142
  end
@@ -130,80 +144,90 @@ describe 'BaseTransport' do
130
144
 
131
145
  describe Thrift::BufferedTransportFactory do
132
146
  it "should wrap the given transport in a BufferedTransport" do
133
- trans = mock("Transport")
134
- btrans = mock("BufferedTransport")
135
- Thrift::BufferedTransport.should_receive(:new).with(trans).and_return(btrans)
136
- Thrift::BufferedTransportFactory.new.get_transport(trans).should == btrans
147
+ trans = double("Transport")
148
+ btrans = double("BufferedTransport")
149
+ expect(Thrift::BufferedTransport).to receive(:new).with(trans).and_return(btrans)
150
+ expect(Thrift::BufferedTransportFactory.new.get_transport(trans)).to eq(btrans)
151
+ end
152
+
153
+ it "should provide a reasonable to_s" do
154
+ expect(Thrift::BufferedTransportFactory.new.to_s).to eq("buffered")
137
155
  end
138
156
  end
139
157
 
140
158
  describe Thrift::FramedTransport do
141
159
  before(:each) do
142
- @trans = mock("Transport")
160
+ @trans = double("Transport")
161
+ end
162
+
163
+ it "should provide a to_s that describes the encapsulation" do
164
+ trans = double("Transport")
165
+ expect(trans).to receive(:to_s).and_return("mock")
166
+ expect(Thrift::FramedTransport.new(trans).to_s).to eq("framed(mock)")
143
167
  end
144
168
 
145
169
  it "should pass through open?/open/close" do
146
170
  ftrans = Thrift::FramedTransport.new(@trans)
147
- @trans.should_receive(:open?).ordered.and_return("+ open?")
148
- @trans.should_receive(:open).ordered.and_return("+ open")
149
- @trans.should_receive(:close).ordered.and_return("+ close")
150
- ftrans.open?.should == "+ open?"
151
- ftrans.open.should == "+ open"
152
- ftrans.close.should == "+ close"
171
+ expect(@trans).to receive(:open?).ordered.and_return("+ open?")
172
+ expect(@trans).to receive(:open).ordered.and_return("+ open")
173
+ expect(@trans).to receive(:close).ordered.and_return("+ close")
174
+ expect(ftrans.open?).to eq("+ open?")
175
+ expect(ftrans.open).to eq("+ open")
176
+ expect(ftrans.close).to eq("+ close")
153
177
  end
154
178
 
155
179
  it "should pass through read when read is turned off" do
156
180
  ftrans = Thrift::FramedTransport.new(@trans, false, true)
157
- @trans.should_receive(:read).with(17).ordered.and_return("+ read")
158
- ftrans.read(17).should == "+ read"
181
+ expect(@trans).to receive(:read).with(17).ordered.and_return("+ read")
182
+ expect(ftrans.read(17)).to eq("+ read")
159
183
  end
160
184
 
161
185
  it "should pass through write/flush when write is turned off" do
162
186
  ftrans = Thrift::FramedTransport.new(@trans, true, false)
163
- @trans.should_receive(:write).with("foo").ordered.and_return("+ write")
164
- @trans.should_receive(:flush).ordered.and_return("+ flush")
165
- ftrans.write("foo").should == "+ write"
166
- ftrans.flush.should == "+ flush"
187
+ expect(@trans).to receive(:write).with("foo").ordered.and_return("+ write")
188
+ expect(@trans).to receive(:flush).ordered.and_return("+ flush")
189
+ expect(ftrans.write("foo")).to eq("+ write")
190
+ expect(ftrans.flush).to eq("+ flush")
167
191
  end
168
192
 
169
193
  it "should return a full frame if asked for >= the frame's length" do
170
194
  frame = "this is a frame"
171
- @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
172
- @trans.should_receive(:read_all).with(frame.length).and_return(frame)
173
- Thrift::FramedTransport.new(@trans).read(frame.length + 10).should == frame
195
+ expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017")
196
+ expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
197
+ expect(Thrift::FramedTransport.new(@trans).read(frame.length + 10)).to eq(frame)
174
198
  end
175
199
 
176
200
  it "should return slices of the frame when asked for < the frame's length" do
177
201
  frame = "this is a frame"
178
- @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
179
- @trans.should_receive(:read_all).with(frame.length).and_return(frame)
202
+ expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017")
203
+ expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
180
204
  ftrans = Thrift::FramedTransport.new(@trans)
181
- ftrans.read(4).should == "this"
182
- ftrans.read(4).should == " is "
183
- ftrans.read(16).should == "a frame"
205
+ expect(ftrans.read(4)).to eq("this")
206
+ expect(ftrans.read(4)).to eq(" is ")
207
+ expect(ftrans.read(16)).to eq("a frame")
184
208
  end
185
209
 
186
210
  it "should return nothing if asked for <= 0" do
187
- Thrift::FramedTransport.new(@trans).read(-2).should == ""
211
+ expect(Thrift::FramedTransport.new(@trans).read(-2)).to eq("")
188
212
  end
189
213
 
190
214
  it "should pull a new frame when the first is exhausted" do
191
215
  frame = "this is a frame"
192
216
  frame2 = "yet another frame"
193
- @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
194
- @trans.should_receive(:read_all).with(frame.length).and_return(frame)
195
- @trans.should_receive(:read_all).with(frame2.length).and_return(frame2)
217
+ expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
218
+ expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
219
+ expect(@trans).to receive(:read_all).with(frame2.length).and_return(frame2)
196
220
  ftrans = Thrift::FramedTransport.new(@trans)
197
- ftrans.read(4).should == "this"
198
- ftrans.read(8).should == " is a fr"
199
- ftrans.read(6).should == "ame"
200
- ftrans.read(4).should == "yet "
201
- ftrans.read(16).should == "another frame"
221
+ expect(ftrans.read(4)).to eq("this")
222
+ expect(ftrans.read(8)).to eq(" is a fr")
223
+ expect(ftrans.read(6)).to eq("ame")
224
+ expect(ftrans.read(4)).to eq("yet ")
225
+ expect(ftrans.read(16)).to eq("another frame")
202
226
  end
203
227
 
204
228
  it "should buffer writes" do
205
229
  ftrans = Thrift::FramedTransport.new(@trans)
206
- @trans.should_not_receive(:write)
230
+ expect(@trans).not_to receive(:write)
207
231
  ftrans.write("foo")
208
232
  ftrans.write("bar")
209
233
  ftrans.write("this is a frame")
@@ -213,15 +237,15 @@ describe 'BaseTransport' do
213
237
  ftrans = Thrift::FramedTransport.new(@trans)
214
238
  ftrans.write("foobar", 3)
215
239
  ftrans.write("barfoo", 1)
216
- @trans.stub!(:flush)
217
- @trans.should_receive(:write).with("\000\000\000\004foob")
240
+ allow(@trans).to receive(:flush)
241
+ expect(@trans).to receive(:write).with("\000\000\000\004foob")
218
242
  ftrans.flush
219
243
  end
220
244
 
221
245
  it "should flush frames with a 4-byte header" do
222
246
  ftrans = Thrift::FramedTransport.new(@trans)
223
- @trans.should_receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
224
- @trans.should_receive(:flush).ordered
247
+ expect(@trans).to receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
248
+ expect(@trans).to receive(:flush).ordered
225
249
  ftrans.write("one/")
226
250
  ftrans.write("two/")
227
251
  ftrans.write("three/")
@@ -231,22 +255,26 @@ describe 'BaseTransport' do
231
255
 
232
256
  it "should not flush the same buffered data twice" do
233
257
  ftrans = Thrift::FramedTransport.new(@trans)
234
- @trans.should_receive(:write).with("\000\000\000\007foo/bar")
235
- @trans.stub!(:flush)
258
+ expect(@trans).to receive(:write).with("\000\000\000\007foo/bar")
259
+ allow(@trans).to receive(:flush)
236
260
  ftrans.write("foo")
237
261
  ftrans.write("/bar")
238
262
  ftrans.flush
239
- @trans.should_receive(:write).with("\000\000\000\000")
263
+ expect(@trans).to receive(:write).with("\000\000\000\000")
240
264
  ftrans.flush
241
265
  end
242
266
  end
243
267
 
244
268
  describe Thrift::FramedTransportFactory do
245
269
  it "should wrap the given transport in a FramedTransport" do
246
- trans = mock("Transport")
247
- Thrift::FramedTransport.should_receive(:new).with(trans)
270
+ trans = double("Transport")
271
+ expect(Thrift::FramedTransport).to receive(:new).with(trans)
248
272
  Thrift::FramedTransportFactory.new.get_transport(trans)
249
273
  end
274
+
275
+ it "should provide a reasonable to_s" do
276
+ expect(Thrift::FramedTransportFactory.new.to_s).to eq("framed")
277
+ end
250
278
  end
251
279
 
252
280
  describe Thrift::MemoryBufferTransport do
@@ -254,96 +282,106 @@ describe 'BaseTransport' do
254
282
  @buffer = Thrift::MemoryBufferTransport.new
255
283
  end
256
284
 
285
+ it "should provide a reasonable to_s" do
286
+ expect(@buffer.to_s).to eq("memory")
287
+ end
288
+
257
289
  it "should accept a buffer on input and use it directly" do
258
290
  s = "this is a test"
259
291
  @buffer = Thrift::MemoryBufferTransport.new(s)
260
- @buffer.read(4).should == "this"
292
+ expect(@buffer.read(4)).to eq("this")
261
293
  s.slice!(-4..-1)
262
- @buffer.read(@buffer.available).should == " is a "
294
+ expect(@buffer.read(@buffer.available)).to eq(" is a ")
263
295
  end
264
296
 
265
297
  it "should always remain open" do
266
- @buffer.should be_open
298
+ expect(@buffer).to be_open
267
299
  @buffer.close
268
- @buffer.should be_open
300
+ expect(@buffer).to be_open
269
301
  end
270
302
 
271
303
  it "should respond to peek and available" do
272
304
  @buffer.write "some data"
273
- @buffer.peek.should be_true
274
- @buffer.available.should == 9
305
+ expect(@buffer.peek).to be_truthy
306
+ expect(@buffer.available).to eq(9)
275
307
  @buffer.read(4)
276
- @buffer.peek.should be_true
277
- @buffer.available.should == 5
308
+ expect(@buffer.peek).to be_truthy
309
+ expect(@buffer.available).to eq(5)
278
310
  @buffer.read(5)
279
- @buffer.peek.should be_false
280
- @buffer.available.should == 0
311
+ expect(@buffer.peek).to be_falsey
312
+ expect(@buffer.available).to eq(0)
281
313
  end
282
314
 
283
315
  it "should be able to reset the buffer" do
284
316
  @buffer.write "test data"
285
317
  @buffer.reset_buffer("foobar")
286
- @buffer.available.should == 6
287
- @buffer.read(@buffer.available).should == "foobar"
318
+ expect(@buffer.available).to eq(6)
319
+ expect(@buffer.read(@buffer.available)).to eq("foobar")
288
320
  @buffer.reset_buffer
289
- @buffer.available.should == 0
321
+ expect(@buffer.available).to eq(0)
290
322
  end
291
323
 
292
324
  it "should copy the given string when resetting the buffer" do
293
325
  s = "this is a test"
294
326
  @buffer.reset_buffer(s)
295
- @buffer.available.should == 14
327
+ expect(@buffer.available).to eq(14)
296
328
  @buffer.read(10)
297
- @buffer.available.should == 4
298
- s.should == "this is a test"
329
+ expect(@buffer.available).to eq(4)
330
+ expect(s).to eq("this is a test")
299
331
  end
300
332
 
301
333
  it "should return from read what was given in write" do
302
334
  @buffer.write "test data"
303
- @buffer.read(4).should == "test"
304
- @buffer.read(@buffer.available).should == " data"
335
+ expect(@buffer.read(4)).to eq("test")
336
+ expect(@buffer.read(@buffer.available)).to eq(" data")
305
337
  @buffer.write "foo"
306
338
  @buffer.write " bar"
307
- @buffer.read(@buffer.available).should == "foo bar"
339
+ expect(@buffer.read(@buffer.available)).to eq("foo bar")
308
340
  end
309
341
 
310
342
  it "should throw an EOFError when there isn't enough data in the buffer" do
311
343
  @buffer.reset_buffer("")
312
- lambda{@buffer.read(1)}.should raise_error(EOFError)
344
+ expect{@buffer.read(1)}.to raise_error(EOFError)
313
345
 
314
346
  @buffer.reset_buffer("1234")
315
- lambda{@buffer.read(5)}.should raise_error(EOFError)
347
+ expect{@buffer.read(5)}.to raise_error(EOFError)
316
348
  end
317
349
  end
318
350
 
319
351
  describe Thrift::IOStreamTransport do
320
352
  before(:each) do
321
- @input = mock("Input", :closed? => false)
322
- @output = mock("Output", :closed? => false)
353
+ @input = double("Input", :closed? => false)
354
+ @output = double("Output", :closed? => false)
323
355
  @trans = Thrift::IOStreamTransport.new(@input, @output)
324
356
  end
325
357
 
358
+ it "should provide a reasonable to_s" do
359
+ expect(@input).to receive(:to_s).and_return("mock_input")
360
+ expect(@output).to receive(:to_s).and_return("mock_output")
361
+ expect(@trans.to_s).to eq("iostream(input=mock_input,output=mock_output)")
362
+ end
363
+
326
364
  it "should be open as long as both input or output are open" do
327
- @trans.should be_open
328
- @input.stub!(:closed?).and_return(true)
329
- @trans.should be_open
330
- @input.stub!(:closed?).and_return(false)
331
- @output.stub!(:closed?).and_return(true)
332
- @trans.should be_open
333
- @input.stub!(:closed?).and_return(true)
334
- @trans.should_not be_open
365
+ expect(@trans).to be_open
366
+ allow(@input).to receive(:closed?).and_return(true)
367
+ expect(@trans).to be_open
368
+ allow(@input).to receive(:closed?).and_return(false)
369
+ allow(@output).to receive(:closed?).and_return(true)
370
+ expect(@trans).to be_open
371
+ allow(@input).to receive(:closed?).and_return(true)
372
+ expect(@trans).not_to be_open
335
373
  end
336
374
 
337
375
  it "should pass through read/write to input/output" do
338
- @input.should_receive(:read).with(17).and_return("+ read")
339
- @output.should_receive(:write).with("foobar").and_return("+ write")
340
- @trans.read(17).should == "+ read"
341
- @trans.write("foobar").should == "+ write"
376
+ expect(@input).to receive(:read).with(17).and_return("+ read")
377
+ expect(@output).to receive(:write).with("foobar").and_return("+ write")
378
+ expect(@trans.read(17)).to eq("+ read")
379
+ expect(@trans.write("foobar")).to eq("+ write")
342
380
  end
343
381
 
344
382
  it "should close both input and output when closed" do
345
- @input.should_receive(:close)
346
- @output.should_receive(:close)
383
+ expect(@input).to receive(:close)
384
+ expect(@output).to receive(:close)
347
385
  @trans.close
348
386
  end
349
387
  end
@@ -33,10 +33,14 @@ if defined? Thrift::BinaryProtocolAccelerated
33
33
 
34
34
  describe Thrift::BinaryProtocolAcceleratedFactory do
35
35
  it "should create a BinaryProtocolAccelerated" do
36
- Thrift::BinaryProtocolAcceleratedFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(Thrift::BinaryProtocolAccelerated)
36
+ expect(Thrift::BinaryProtocolAcceleratedFactory.new.get_protocol(double("MockTransport"))).to be_instance_of(Thrift::BinaryProtocolAccelerated)
37
+ end
38
+
39
+ it "should provide a reasonable to_s" do
40
+ expect(Thrift::BinaryProtocolAcceleratedFactory.new.to_s).to eq("binary-accel")
37
41
  end
38
42
  end
39
43
  end
40
44
  else
41
45
  puts "skipping BinaryProtocolAccelerated spec because it is not defined."
42
- end
46
+ end
@@ -38,29 +38,37 @@ describe 'BinaryProtocol' do
38
38
  it "should read a message header" do
39
39
  @trans.write([protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::REPLY].pack('N'))
40
40
  @trans.write([42].pack('N'))
41
- @prot.should_receive(:read_string).and_return('testMessage')
42
- @prot.read_message_begin.should == ['testMessage', Thrift::MessageTypes::REPLY, 42]
41
+ expect(@prot).to receive(:read_string).and_return('testMessage')
42
+ expect(@prot.read_message_begin).to eq(['testMessage', Thrift::MessageTypes::REPLY, 42])
43
43
  end
44
44
 
45
45
  it "should raise an exception if the message header has the wrong version" do
46
- @prot.should_receive(:read_i32).and_return(-1)
47
- lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'Missing version identifier') do |e|
46
+ expect(@prot).to receive(:read_i32).and_return(-1)
47
+ expect { @prot.read_message_begin }.to raise_error(Thrift::ProtocolException, 'Missing version identifier') do |e|
48
48
  e.type == Thrift::ProtocolException::BAD_VERSION
49
49
  end
50
50
  end
51
51
 
52
52
  it "should raise an exception if the message header does not exist and strict_read is enabled" do
53
- @prot.should_receive(:read_i32).and_return(42)
54
- @prot.should_receive(:strict_read).and_return(true)
55
- lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'No version identifier, old protocol client?') do |e|
53
+ expect(@prot).to receive(:read_i32).and_return(42)
54
+ expect(@prot).to receive(:strict_read).and_return(true)
55
+ expect { @prot.read_message_begin }.to raise_error(Thrift::ProtocolException, 'No version identifier, old protocol client?') do |e|
56
56
  e.type == Thrift::ProtocolException::BAD_VERSION
57
57
  end
58
58
  end
59
+
60
+ it "should provide a reasonable to_s" do
61
+ expect(@prot.to_s).to eq("binary(memory)")
62
+ end
59
63
  end
60
64
 
61
65
  describe Thrift::BinaryProtocolFactory do
62
66
  it "should create a BinaryProtocol" do
63
- Thrift::BinaryProtocolFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(Thrift::BinaryProtocol)
67
+ expect(Thrift::BinaryProtocolFactory.new.get_protocol(double("MockTransport"))).to be_instance_of(Thrift::BinaryProtocol)
68
+ end
69
+
70
+ it "should provide a reasonable to_s" do
71
+ expect(Thrift::BinaryProtocolFactory.new.to_s).to eq("binary")
64
72
  end
65
73
  end
66
74
  end