thrift 0.11.0.0 → 0.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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 +4 -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 +42 -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 +134 -154
  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
@@ -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
@@ -21,84 +21,84 @@ require 'spec_helper'
21
21
 
22
22
  shared_examples_for "a socket" do
23
23
  it "should open a socket" do
24
- @socket.open.should == @handle
24
+ expect(@socket.open).to eq(@handle)
25
25
  end
26
26
 
27
27
  it "should be open whenever it has a handle" do
28
- @socket.should_not be_open
28
+ expect(@socket).not_to be_open
29
29
  @socket.open
30
- @socket.should be_open
30
+ expect(@socket).to be_open
31
31
  @socket.handle = nil
32
- @socket.should_not be_open
32
+ expect(@socket).not_to be_open
33
33
  @socket.handle = @handle
34
34
  @socket.close
35
- @socket.should_not be_open
35
+ expect(@socket).not_to be_open
36
36
  end
37
37
 
38
38
  it "should write data to the handle" do
39
39
  @socket.open
40
- @handle.should_receive(:write).with("foobar")
40
+ expect(@handle).to receive(:write).with("foobar")
41
41
  @socket.write("foobar")
42
- @handle.should_receive(:write).with("fail").and_raise(StandardError)
43
- lambda { @socket.write("fail") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
42
+ expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
43
+ expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
44
44
  end
45
45
 
46
46
  it "should raise an error when it cannot read from the handle" do
47
47
  @socket.open
48
- @handle.should_receive(:readpartial).with(17).and_raise(StandardError)
49
- lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
48
+ expect(@handle).to receive(:readpartial).with(17).and_raise(StandardError)
49
+ expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
50
50
  end
51
51
 
52
52
  it "should return the data read when reading from the handle works" do
53
53
  @socket.open
54
- @handle.should_receive(:readpartial).with(17).and_return("test data")
55
- @socket.read(17).should == "test data"
54
+ expect(@handle).to receive(:readpartial).with(17).and_return("test data")
55
+ expect(@socket.read(17)).to eq("test data")
56
56
  end
57
57
 
58
58
  it "should declare itself as closed when it has an error" do
59
59
  @socket.open
60
- @handle.should_receive(:write).with("fail").and_raise(StandardError)
61
- @socket.should be_open
62
- lambda { @socket.write("fail") }.should raise_error
63
- @socket.should_not be_open
60
+ expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
61
+ expect(@socket).to be_open
62
+ expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
63
+ expect(@socket).not_to be_open
64
64
  end
65
65
 
66
66
  it "should raise an error when the stream is closed" do
67
67
  @socket.open
68
- @handle.stub!(:closed?).and_return(true)
69
- @socket.should_not be_open
70
- lambda { @socket.write("fail") }.should raise_error(IOError, "closed stream")
71
- lambda { @socket.read(10) }.should raise_error(IOError, "closed stream")
68
+ allow(@handle).to receive(:closed?).and_return(true)
69
+ expect(@socket).not_to be_open
70
+ expect { @socket.write("fail") }.to raise_error(IOError, "closed stream")
71
+ expect { @socket.read(10) }.to raise_error(IOError, "closed stream")
72
72
  end
73
73
 
74
74
  it "should support the timeout accessor for read" do
75
75
  @socket.timeout = 3
76
76
  @socket.open
77
- IO.should_receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
78
- @handle.should_receive(:readpartial).with(17).and_return("test data")
79
- @socket.read(17).should == "test data"
77
+ expect(IO).to receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
78
+ expect(@handle).to receive(:readpartial).with(17).and_return("test data")
79
+ expect(@socket.read(17)).to eq("test data")
80
80
  end
81
81
 
82
82
  it "should support the timeout accessor for write" do
83
83
  @socket.timeout = 3
84
84
  @socket.open
85
- IO.should_receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
86
- @handle.should_receive(:write_nonblock).with("test data").and_return(4)
87
- @handle.should_receive(:write_nonblock).with(" data").and_return(5)
88
- @socket.write("test data").should == 9
85
+ expect(IO).to receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
86
+ expect(@handle).to receive(:write_nonblock).with("test data").and_return(4)
87
+ expect(@handle).to receive(:write_nonblock).with(" data").and_return(5)
88
+ expect(@socket.write("test data")).to eq(9)
89
89
  end
90
90
 
91
91
  it "should raise an error when read times out" do
92
92
  @socket.timeout = 0.5
93
93
  @socket.open
94
- IO.should_receive(:select).once {sleep(0.5); nil}
95
- lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
94
+ expect(IO).to receive(:select).once {sleep(0.5); nil}
95
+ expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
96
96
  end
97
97
 
98
98
  it "should raise an error when write times out" do
99
99
  @socket.timeout = 0.5
100
100
  @socket.open
101
- IO.should_receive(:select).with(nil, [@handle], nil, 0.5).any_number_of_times.and_return(nil)
102
- lambda { @socket.write("test data") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
101
+ allow(IO).to receive(:select).with(nil, [@handle], nil, 0.5).and_return(nil)
102
+ expect { @socket.write("test data") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
103
103
  end
104
104
  end
@@ -0,0 +1,34 @@
1
+ #
2
+ # Licensed to the Apache Software Foundation (ASF) under one
3
+ # or more contributor license agreements. See the NOTICE file
4
+ # distributed with this work for additional information
5
+ # regarding copyright ownership. The ASF licenses this file
6
+ # to you under the Apache License, Version 2.0 (the
7
+ # "License"); you may not use this file except in compliance
8
+ # with the License. You may obtain a copy of the License at
9
+ #
10
+ # http://www.apache.org/licenses/LICENSE-2.0
11
+ #
12
+ # Unless required by applicable law or agreed to in writing,
13
+ # software distributed under the License is distributed on an
14
+ # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15
+ # KIND, either express or implied. See the License for the
16
+ # specific language governing permissions and limitations
17
+ # under the License.
18
+ #
19
+
20
+ require 'spec_helper'
21
+ require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
22
+
23
+ describe 'SSLServerSocket' do
24
+
25
+ describe Thrift::SSLServerSocket do
26
+ before(:each) do
27
+ @socket = Thrift::SSLServerSocket.new(1234)
28
+ end
29
+
30
+ it "should provide a reasonable to_s" do
31
+ expect(@socket.to_s).to eq("ssl(socket(:1234))")
32
+ end
33
+ end
34
+ end
@@ -26,49 +26,53 @@ describe 'SSLSocket' do
26
26
  before(:each) do
27
27
  @context = OpenSSL::SSL::SSLContext.new
28
28
  @socket = Thrift::SSLSocket.new
29
- @simple_socket_handle = mock("Handle", :closed? => false)
30
- @simple_socket_handle.stub!(:close)
31
- @simple_socket_handle.stub!(:connect_nonblock)
32
- @simple_socket_handle.stub!(:setsockopt)
29
+ @simple_socket_handle = double("Handle", :closed? => false)
30
+ allow(@simple_socket_handle).to receive(:close)
31
+ allow(@simple_socket_handle).to receive(:connect_nonblock)
32
+ allow(@simple_socket_handle).to receive(:setsockopt)
33
33
 
34
- @handle = mock(mock("SSLHandle", :connect_nonblock => true, :post_connection_check => true), :closed? => false)
35
- @handle.stub!(:connect_nonblock)
36
- @handle.stub!(:close)
37
- @handle.stub!(:post_connection_check)
34
+ @handle = double(double("SSLHandle", :connect_nonblock => true, :post_connection_check => true), :closed? => false)
35
+ allow(@handle).to receive(:connect_nonblock)
36
+ allow(@handle).to receive(:close)
37
+ allow(@handle).to receive(:post_connection_check)
38
38
 
39
- ::Socket.stub!(:new).and_return(@simple_socket_handle)
40
- OpenSSL::SSL::SSLSocket.stub!(:new).and_return(@handle)
39
+ allow(::Socket).to receive(:new).and_return(@simple_socket_handle)
40
+ allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@handle)
41
41
  end
42
42
 
43
43
  it_should_behave_like "a socket"
44
44
 
45
45
  it "should raise a TransportException when it cannot open a ssl socket" do
46
- ::Socket.should_receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
47
- lambda { @socket.open }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
46
+ expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
47
+ expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
48
48
  end
49
49
 
50
50
  it "should open a ::Socket with default args" do
51
- OpenSSL::SSL::SSLSocket.should_receive(:new).with(@simple_socket_handle, nil).and_return(@handle)
52
- @handle.should_receive(:post_connection_check).with('localhost')
51
+ expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_return(@handle)
52
+ expect(@handle).to receive(:post_connection_check).with('localhost')
53
53
  @socket.open
54
54
  end
55
55
 
56
56
  it "should accept host/port options" do
57
- handle = mock("Handle", :connect_nonblock => true, :setsockopt => nil)
58
- ::Socket.stub!(:new).and_return(handle)
59
- ::Socket.should_receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
60
- ::Socket.should_receive(:sockaddr_in)
61
- OpenSSL::SSL::SSLSocket.should_receive(:new).with(handle, nil).and_return(@handle)
62
- @handle.should_receive(:post_connection_check).with('my.domain')
57
+ handle = double("Handle", :connect_nonblock => true, :setsockopt => nil)
58
+ allow(::Socket).to receive(:new).and_return(handle)
59
+ expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
60
+ expect(::Socket).to receive(:sockaddr_in)
61
+ expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(handle, nil).and_return(@handle)
62
+ expect(@handle).to receive(:post_connection_check).with('my.domain')
63
63
  Thrift::SSLSocket.new('my.domain', 1234, 6000, nil).open
64
64
  end
65
65
 
66
66
  it "should accept an optional timeout" do
67
- Thrift::SSLSocket.new('localhost', 8080, 5).timeout.should == 5
67
+ expect(Thrift::SSLSocket.new('localhost', 8080, 5).timeout).to eq(5)
68
68
  end
69
69
 
70
70
  it "should accept an optional context" do
71
- Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context.should == @context
71
+ expect(Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context).to eq(@context)
72
+ end
73
+
74
+ it "should provide a reasonable to_s" do
75
+ expect(Thrift::SSLSocket.new('myhost', 8090).to_s).to eq("ssl(socket(myhost:8090))")
72
76
  end
73
77
  end
74
78
  end
@@ -39,9 +39,9 @@ describe 'StructNestedContainers' do
39
39
  thrift_struct.value = [ [1, 2, 3], [2, 3, 4] ]
40
40
  thrift_struct.validate
41
41
  end
42
- a.should == b
42
+ expect(a).to eq(b)
43
43
  b.value.push [3, 4, 5]
44
- a.should_not == b
44
+ expect(a).not_to eq(b)
45
45
  end
46
46
  end
47
47
 
@@ -52,9 +52,9 @@ describe 'StructNestedContainers' do
52
52
  thrift_struct.value = [ [1, 2, 3], [2, 3, 4] ].to_set
53
53
  thrift_struct.validate
54
54
  end
55
- a.should == b
55
+ expect(a).to eq(b)
56
56
  b.value.add [3, 4, 5]
57
- a.should_not == b
57
+ expect(a).not_to eq(b)
58
58
  end
59
59
  end
60
60
 
@@ -65,9 +65,9 @@ describe 'StructNestedContainers' do
65
65
  thrift_struct.value = { [1, 2, 3] => 1, [2, 3, 4] => 2 }
66
66
  thrift_struct.validate
67
67
  end
68
- a.should == b
68
+ expect(a).to eq(b)
69
69
  b.value[[3, 4, 5]] = 3
70
- a.should_not == b
70
+ expect(a).not_to eq(b)
71
71
  end
72
72
  end
73
73
 
@@ -78,9 +78,9 @@ describe 'StructNestedContainers' do
78
78
  thrift_struct.value = { 1 => [1, 2, 3], 2 => [2, 3, 4] }
79
79
  thrift_struct.validate
80
80
  end
81
- a.should == b
81
+ expect(a).to eq(b)
82
82
  b.value[3] = [3, 4, 5]
83
- a.should_not == b
83
+ expect(a).not_to eq(b)
84
84
  end
85
85
  end
86
86
 
@@ -91,9 +91,9 @@ describe 'StructNestedContainers' do
91
91
  thrift_struct.value = [ [1, 2, 3].to_set, [2, 3, 4].to_set ]
92
92
  thrift_struct.validate
93
93
  end
94
- a.should == b
94
+ expect(a).to eq(b)
95
95
  b.value.push([3, 4, 5].to_set)
96
- a.should_not == b
96
+ expect(a).not_to eq(b)
97
97
  end
98
98
  end
99
99
 
@@ -104,9 +104,9 @@ describe 'StructNestedContainers' do
104
104
  thrift_struct.value = [ [1, 2, 3].to_set, [2, 3, 4].to_set ].to_set
105
105
  thrift_struct.validate
106
106
  end
107
- a.should == b
107
+ expect(a).to eq(b)
108
108
  b.value.add([3, 4, 5].to_set)
109
- a.should_not == b
109
+ expect(a).not_to eq(b)
110
110
  end
111
111
  end
112
112
 
@@ -117,9 +117,9 @@ describe 'StructNestedContainers' do
117
117
  thrift_struct.value = { [1, 2, 3].to_set => 1, [2, 3, 4].to_set => 2 }
118
118
  thrift_struct.validate
119
119
  end
120
- a.should == b
120
+ expect(a).to eq(b)
121
121
  b.value[[3, 4, 5].to_set] = 3
122
- a.should_not == b
122
+ expect(a).not_to eq(b)
123
123
  end
124
124
  end
125
125
 
@@ -130,9 +130,9 @@ describe 'StructNestedContainers' do
130
130
  thrift_struct.value = { 1 => [1, 2, 3].to_set, 2 => [2, 3, 4].to_set }
131
131
  thrift_struct.validate
132
132
  end
133
- a.should == b
133
+ expect(a).to eq(b)
134
134
  b.value[3] = [3, 4, 5].to_set
135
- a.should_not == b
135
+ expect(a).not_to eq(b)
136
136
  end
137
137
  end
138
138
 
@@ -143,9 +143,9 @@ describe 'StructNestedContainers' do
143
143
  thrift_struct.value = [ {1 => 2, 3 => 4}, {2 => 3, 4 => 5} ]
144
144
  thrift_struct.validate
145
145
  end
146
- a.should == b
146
+ expect(a).to eq(b)
147
147
  b.value.push({ 3 => 4, 5 => 6 })
148
- a.should_not == b
148
+ expect(a).not_to eq(b)
149
149
  end
150
150
  end
151
151
 
@@ -156,9 +156,9 @@ describe 'StructNestedContainers' do
156
156
  thrift_struct.value = [ {1 => 2, 3 => 4}, {2 => 3, 4 => 5} ].to_set
157
157
  thrift_struct.validate
158
158
  end
159
- a.should == b
159
+ expect(a).to eq(b)
160
160
  b.value.add({ 3 => 4, 5 => 6 })
161
- a.should_not == b
161
+ expect(a).not_to eq(b)
162
162
  end
163
163
  end
164
164
 
@@ -169,9 +169,9 @@ describe 'StructNestedContainers' do
169
169
  thrift_struct.value = { { 1 => 2, 3 => 4} => 1, {2 => 3, 4 => 5} => 2 }
170
170
  thrift_struct.validate
171
171
  end
172
- a.should == b
172
+ expect(a).to eq(b)
173
173
  b.value[{3 => 4, 5 => 6}] = 3
174
- a.should_not == b
174
+ expect(a).not_to eq(b)
175
175
  end
176
176
  end
177
177
 
@@ -182,9 +182,9 @@ describe 'StructNestedContainers' do
182
182
  thrift_struct.value = { 1 => { 1 => 2, 3 => 4}, 2 => {2 => 3, 4 => 5} }
183
183
  thrift_struct.validate
184
184
  end
185
- a.should == b
185
+ expect(a).to eq(b)
186
186
  b.value[3] = { 3 => 4, 5 => 6 }
187
- a.should_not == b
187
+ expect(a).not_to eq(b)
188
188
  end
189
189
  end
190
190
  end
@@ -25,7 +25,7 @@ describe 'Struct' do
25
25
  it "should iterate over all fields properly" do
26
26
  fields = {}
27
27
  SpecNamespace::Foo.new.each_field { |fid,field_info| fields[fid] = field_info }
28
- fields.should == SpecNamespace::Foo::FIELDS
28
+ expect(fields).to eq(SpecNamespace::Foo::FIELDS)
29
29
  end
30
30
 
31
31
  it "should initialize all fields to defaults" do
@@ -39,19 +39,19 @@ describe 'Struct' do
39
39
  end
40
40
 
41
41
  def validate_default_arguments(object)
42
- object.simple.should == 53
43
- object.words.should == "words"
44
- object.hello.should == SpecNamespace::Hello.new(:greeting => 'hello, world!')
45
- object.ints.should == [1, 2, 2, 3]
46
- object.complex.should be_nil
47
- object.shorts.should == Set.new([5, 17, 239])
42
+ expect(object.simple).to eq(53)
43
+ expect(object.words).to eq("words")
44
+ expect(object.hello).to eq(SpecNamespace::Hello.new(:greeting => 'hello, world!'))
45
+ expect(object.ints).to eq([1, 2, 2, 3])
46
+ expect(object.complex).to be_nil
47
+ expect(object.shorts).to eq(Set.new([5, 17, 239]))
48
48
  end
49
49
 
50
50
  it "should not share default values between instances" do
51
51
  begin
52
52
  struct = SpecNamespace::Foo.new
53
53
  struct.ints << 17
54
- SpecNamespace::Foo.new.ints.should == [1,2,2,3]
54
+ expect(SpecNamespace::Foo.new.ints).to eq([1,2,2,3])
55
55
  ensure
56
56
  # ensure no leakage to other tests
57
57
  SpecNamespace::Foo::FIELDS[4][:default] = [1,2,2,3]
@@ -60,48 +60,48 @@ describe 'Struct' do
60
60
 
61
61
  it "should properly initialize boolean values" do
62
62
  struct = SpecNamespace::BoolStruct.new(:yesno => false)
63
- struct.yesno.should be_false
63
+ expect(struct.yesno).to be_falsey
64
64
  end
65
65
 
66
66
  it "should have proper == semantics" do
67
- SpecNamespace::Foo.new.should_not == SpecNamespace::Hello.new
68
- SpecNamespace::Foo.new.should == SpecNamespace::Foo.new
69
- SpecNamespace::Foo.new(:simple => 52).should_not == SpecNamespace::Foo.new
67
+ expect(SpecNamespace::Foo.new).not_to eq(SpecNamespace::Hello.new)
68
+ expect(SpecNamespace::Foo.new).to eq(SpecNamespace::Foo.new)
69
+ expect(SpecNamespace::Foo.new(:simple => 52)).not_to eq(SpecNamespace::Foo.new)
70
70
  end
71
71
 
72
72
  it "should print enum value names in inspect" do
73
- SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect.should == "<SpecNamespace::StructWithSomeEnum some_enum:ONE (0)>"
73
+ expect(SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect).to eq("<SpecNamespace::StructWithSomeEnum some_enum:ONE (0)>")
74
74
 
75
- SpecNamespace::StructWithEnumMap.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect.should == "<SpecNamespace::StructWithEnumMap my_map:{ONE (0): [TWO (1)]}>"
75
+ expect(SpecNamespace::StructWithEnumMap.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect).to eq("<SpecNamespace::StructWithEnumMap my_map:{ONE (0): [TWO (1)]}>")
76
76
  end
77
77
 
78
78
  it "should pretty print binary fields" do
79
- SpecNamespace::Foo2.new(:my_binary => "\001\002\003").inspect.should == "<SpecNamespace::Foo2 my_binary:010203>"
79
+ expect(SpecNamespace::Foo2.new(:my_binary => "\001\002\003").inspect).to eq("<SpecNamespace::Foo2 my_binary:010203>")
80
80
  end
81
81
 
82
82
  it "should offer field? methods" do
83
- SpecNamespace::Foo.new.opt_string?.should be_false
84
- SpecNamespace::Foo.new(:simple => 52).simple?.should be_true
85
- SpecNamespace::Foo.new(:my_bool => false).my_bool?.should be_true
86
- SpecNamespace::Foo.new(:my_bool => true).my_bool?.should be_true
83
+ expect(SpecNamespace::Foo.new.opt_string?).to be_falsey
84
+ expect(SpecNamespace::Foo.new(:simple => 52).simple?).to be_truthy
85
+ expect(SpecNamespace::Foo.new(:my_bool => false).my_bool?).to be_truthy
86
+ expect(SpecNamespace::Foo.new(:my_bool => true).my_bool?).to be_truthy
87
87
  end
88
88
 
89
89
  it "should be comparable" do
90
90
  s1 = SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE)
91
91
  s2 = SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::TWO)
92
92
 
93
- (s1 <=> s2).should == -1
94
- (s2 <=> s1).should == 1
95
- (s1 <=> s1).should == 0
96
- (s1 <=> SpecNamespace::StructWithSomeEnum.new()).should == -1
93
+ expect(s1 <=> s2).to eq(-1)
94
+ expect(s2 <=> s1).to eq(1)
95
+ expect(s1 <=> s1).to eq(0)
96
+ expect(s1 <=> SpecNamespace::StructWithSomeEnum.new()).to eq(-1)
97
97
  end
98
98
 
99
99
  it "should read itself off the wire" do
100
100
  struct = SpecNamespace::Foo.new
101
- prot = Thrift::BaseProtocol.new(mock("transport"))
102
- prot.should_receive(:read_struct_begin).twice
103
- prot.should_receive(:read_struct_end).twice
104
- prot.should_receive(:read_field_begin).and_return(
101
+ prot = Thrift::BaseProtocol.new(double("transport"))
102
+ expect(prot).to receive(:read_struct_begin).twice
103
+ expect(prot).to receive(:read_struct_end).twice
104
+ expect(prot).to receive(:read_field_begin).and_return(
105
105
  ['complex', Thrift::Types::MAP, 5], # Foo
106
106
  ['words', Thrift::Types::STRING, 2], # Foo
107
107
  ['hello', Thrift::Types::STRUCT, 3], # Foo
@@ -112,49 +112,49 @@ describe 'Struct' do
112
112
  ['shorts', Thrift::Types::SET, 6], # Foo
113
113
  [nil, Thrift::Types::STOP, 0] # Hello
114
114
  )
115
- prot.should_receive(:read_field_end).exactly(7).times
116
- prot.should_receive(:read_map_begin).and_return(
115
+ expect(prot).to receive(:read_field_end).exactly(7).times
116
+ expect(prot).to receive(:read_map_begin).and_return(
117
117
  [Thrift::Types::I32, Thrift::Types::MAP, 2], # complex
118
118
  [Thrift::Types::STRING, Thrift::Types::DOUBLE, 2], # complex/1/value
119
119
  [Thrift::Types::STRING, Thrift::Types::DOUBLE, 1] # complex/2/value
120
120
  )
121
- prot.should_receive(:read_map_end).exactly(3).times
122
- prot.should_receive(:read_list_begin).and_return([Thrift::Types::I32, 4])
123
- prot.should_receive(:read_list_end)
124
- prot.should_receive(:read_set_begin).and_return([Thrift::Types::I16, 2])
125
- prot.should_receive(:read_set_end)
126
- prot.should_receive(:read_i32).and_return(
121
+ expect(prot).to receive(:read_map_end).exactly(3).times
122
+ expect(prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, 4])
123
+ expect(prot).to receive(:read_list_end)
124
+ expect(prot).to receive(:read_set_begin).and_return([Thrift::Types::I16, 2])
125
+ expect(prot).to receive(:read_set_end)
126
+ expect(prot).to receive(:read_i32).and_return(
127
127
  1, 14, # complex keys
128
128
  42, # simple
129
129
  4, 23, 4, 29 # ints
130
130
  )
131
- prot.should_receive(:read_string).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?")
132
- prot.should_receive(:read_double).and_return(Math::PI, Math::E, 4.669201609)
133
- prot.should_receive(:read_i16).and_return(2, 3)
134
- prot.should_not_receive(:skip)
131
+ expect(prot).to receive(:read_string).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?")
132
+ expect(prot).to receive(:read_double).and_return(Math::PI, Math::E, 4.669201609)
133
+ expect(prot).to receive(:read_i16).and_return(2, 3)
134
+ expect(prot).not_to receive(:skip)
135
135
  struct.read(prot)
136
136
 
137
- struct.simple.should == 42
138
- struct.complex.should == {1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}}
139
- struct.hello.should == SpecNamespace::Hello.new(:greeting => "what's up?")
140
- struct.words.should == "apple banana"
141
- struct.ints.should == [4, 23, 4, 29]
142
- struct.shorts.should == Set.new([3, 2])
137
+ expect(struct.simple).to eq(42)
138
+ expect(struct.complex).to eq({1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}})
139
+ expect(struct.hello).to eq(SpecNamespace::Hello.new(:greeting => "what's up?"))
140
+ expect(struct.words).to eq("apple banana")
141
+ expect(struct.ints).to eq([4, 23, 4, 29])
142
+ expect(struct.shorts).to eq(Set.new([3, 2]))
143
143
  end
144
144
 
145
145
  it "should serialize false boolean fields correctly" do
146
146
  b = SpecNamespace::BoolStruct.new(:yesno => false)
147
147
  prot = Thrift::BinaryProtocol.new(Thrift::MemoryBufferTransport.new)
148
- prot.should_receive(:write_bool).with(false)
148
+ expect(prot).to receive(:write_bool).with(false)
149
149
  b.write(prot)
150
150
  end
151
151
 
152
152
  it "should skip unexpected fields in structs and use default values" do
153
153
  struct = SpecNamespace::Foo.new
154
- prot = Thrift::BaseProtocol.new(mock("transport"))
155
- prot.should_receive(:read_struct_begin)
156
- prot.should_receive(:read_struct_end)
157
- prot.should_receive(:read_field_begin).and_return(
154
+ prot = Thrift::BaseProtocol.new(double("transport"))
155
+ expect(prot).to receive(:read_struct_begin)
156
+ expect(prot).to receive(:read_struct_end)
157
+ expect(prot).to receive(:read_field_begin).and_return(
158
158
  ['simple', Thrift::Types::I32, 1],
159
159
  ['complex', Thrift::Types::STRUCT, 5],
160
160
  ['thinz', Thrift::Types::MAP, 7],
@@ -162,55 +162,55 @@ describe 'Struct' do
162
162
  ['words', Thrift::Types::STRING, 2],
163
163
  [nil, Thrift::Types::STOP, 0]
164
164
  )
165
- prot.should_receive(:read_field_end).exactly(5).times
166
- prot.should_receive(:read_i32).and_return(42)
167
- prot.should_receive(:read_string).and_return("foobar")
168
- prot.should_receive(:skip).with(Thrift::Types::STRUCT)
169
- prot.should_receive(:skip).with(Thrift::Types::MAP)
165
+ expect(prot).to receive(:read_field_end).exactly(5).times
166
+ expect(prot).to receive(:read_i32).and_return(42)
167
+ expect(prot).to receive(:read_string).and_return("foobar")
168
+ expect(prot).to receive(:skip).with(Thrift::Types::STRUCT)
169
+ expect(prot).to receive(:skip).with(Thrift::Types::MAP)
170
170
  # prot.should_receive(:read_map_begin).and_return([Thrift::Types::I32, Thrift::Types::I32, 0])
171
171
  # prot.should_receive(:read_map_end)
172
- prot.should_receive(:skip).with(Thrift::Types::I32)
172
+ expect(prot).to receive(:skip).with(Thrift::Types::I32)
173
173
  struct.read(prot)
174
174
 
175
- struct.simple.should == 42
176
- struct.complex.should be_nil
177
- struct.words.should == "foobar"
178
- struct.hello.should == SpecNamespace::Hello.new(:greeting => 'hello, world!')
179
- struct.ints.should == [1, 2, 2, 3]
180
- struct.shorts.should == Set.new([5, 17, 239])
175
+ expect(struct.simple).to eq(42)
176
+ expect(struct.complex).to be_nil
177
+ expect(struct.words).to eq("foobar")
178
+ expect(struct.hello).to eq(SpecNamespace::Hello.new(:greeting => 'hello, world!'))
179
+ expect(struct.ints).to eq([1, 2, 2, 3])
180
+ expect(struct.shorts).to eq(Set.new([5, 17, 239]))
181
181
  end
182
182
 
183
183
  it "should write itself to the wire" do
184
- prot = Thrift::BaseProtocol.new(mock("transport")) #mock("Protocol")
185
- prot.should_receive(:write_struct_begin).with("SpecNamespace::Foo")
186
- prot.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
187
- prot.should_receive(:write_struct_end).twice
188
- prot.should_receive(:write_field_begin).with('ints', Thrift::Types::LIST, 4)
189
- prot.should_receive(:write_i32).with(1)
190
- prot.should_receive(:write_i32).with(2).twice
191
- prot.should_receive(:write_i32).with(3)
192
- prot.should_receive(:write_field_begin).with('complex', Thrift::Types::MAP, 5)
193
- prot.should_receive(:write_i32).with(5)
194
- prot.should_receive(:write_string).with('foo')
195
- prot.should_receive(:write_double).with(1.23)
196
- prot.should_receive(:write_field_begin).with('shorts', Thrift::Types::SET, 6)
197
- prot.should_receive(:write_i16).with(5)
198
- prot.should_receive(:write_i16).with(17)
199
- prot.should_receive(:write_i16).with(239)
200
- prot.should_receive(:write_field_stop).twice
201
- prot.should_receive(:write_field_end).exactly(6).times
202
- prot.should_receive(:write_field_begin).with('simple', Thrift::Types::I32, 1)
203
- prot.should_receive(:write_i32).with(53)
204
- prot.should_receive(:write_field_begin).with('hello', Thrift::Types::STRUCT, 3)
205
- prot.should_receive(:write_field_begin).with('greeting', Thrift::Types::STRING, 1)
206
- prot.should_receive(:write_string).with('hello, world!')
207
- prot.should_receive(:write_map_begin).with(Thrift::Types::I32, Thrift::Types::MAP, 1)
208
- prot.should_receive(:write_map_begin).with(Thrift::Types::STRING, Thrift::Types::DOUBLE, 1)
209
- prot.should_receive(:write_map_end).twice
210
- prot.should_receive(:write_list_begin).with(Thrift::Types::I32, 4)
211
- prot.should_receive(:write_list_end)
212
- prot.should_receive(:write_set_begin).with(Thrift::Types::I16, 3)
213
- prot.should_receive(:write_set_end)
184
+ prot = Thrift::BaseProtocol.new(double("transport")) #mock("Protocol")
185
+ expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Foo")
186
+ expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Hello")
187
+ expect(prot).to receive(:write_struct_end).twice
188
+ expect(prot).to receive(:write_field_begin).with('ints', Thrift::Types::LIST, 4)
189
+ expect(prot).to receive(:write_i32).with(1)
190
+ expect(prot).to receive(:write_i32).with(2).twice
191
+ expect(prot).to receive(:write_i32).with(3)
192
+ expect(prot).to receive(:write_field_begin).with('complex', Thrift::Types::MAP, 5)
193
+ expect(prot).to receive(:write_i32).with(5)
194
+ expect(prot).to receive(:write_string).with('foo')
195
+ expect(prot).to receive(:write_double).with(1.23)
196
+ expect(prot).to receive(:write_field_begin).with('shorts', Thrift::Types::SET, 6)
197
+ expect(prot).to receive(:write_i16).with(5)
198
+ expect(prot).to receive(:write_i16).with(17)
199
+ expect(prot).to receive(:write_i16).with(239)
200
+ expect(prot).to receive(:write_field_stop).twice
201
+ expect(prot).to receive(:write_field_end).exactly(6).times
202
+ expect(prot).to receive(:write_field_begin).with('simple', Thrift::Types::I32, 1)
203
+ expect(prot).to receive(:write_i32).with(53)
204
+ expect(prot).to receive(:write_field_begin).with('hello', Thrift::Types::STRUCT, 3)
205
+ expect(prot).to receive(:write_field_begin).with('greeting', Thrift::Types::STRING, 1)
206
+ expect(prot).to receive(:write_string).with('hello, world!')
207
+ expect(prot).to receive(:write_map_begin).with(Thrift::Types::I32, Thrift::Types::MAP, 1)
208
+ expect(prot).to receive(:write_map_begin).with(Thrift::Types::STRING, Thrift::Types::DOUBLE, 1)
209
+ expect(prot).to receive(:write_map_end).twice
210
+ expect(prot).to receive(:write_list_begin).with(Thrift::Types::I32, 4)
211
+ expect(prot).to receive(:write_list_end)
212
+ expect(prot).to receive(:write_set_begin).with(Thrift::Types::I16, 3)
213
+ expect(prot).to receive(:write_set_end)
214
214
 
215
215
  struct = SpecNamespace::Foo.new
216
216
  struct.words = nil
@@ -221,50 +221,50 @@ describe 'Struct' do
221
221
  it "should raise an exception if presented with an unknown container" do
222
222
  # yeah this is silly, but I'm going for code coverage here
223
223
  struct = SpecNamespace::Foo.new
224
- lambda { struct.send :write_container, nil, nil, {:type => "foo"} }.should raise_error(StandardError, "Not a container type: foo")
224
+ expect { struct.send :write_container, nil, nil, {:type => "foo"} }.to raise_error(StandardError, "Not a container type: foo")
225
225
  end
226
226
 
227
227
  it "should support optional type-checking in Thrift::Struct.new" do
228
228
  Thrift.type_checking = true
229
229
  begin
230
- lambda { SpecNamespace::Hello.new(:greeting => 3) }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Fixnum for field greeting")
230
+ expect { SpecNamespace::Hello.new(:greeting => 3) }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
231
231
  ensure
232
232
  Thrift.type_checking = false
233
233
  end
234
- lambda { SpecNamespace::Hello.new(:greeting => 3) }.should_not raise_error(Thrift::TypeError)
234
+ expect { SpecNamespace::Hello.new(:greeting => 3) }.not_to raise_error
235
235
  end
236
236
 
237
237
  it "should support optional type-checking in field accessors" do
238
238
  Thrift.type_checking = true
239
239
  begin
240
240
  hello = SpecNamespace::Hello.new
241
- lambda { hello.greeting = 3 }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Fixnum for field greeting")
241
+ expect { hello.greeting = 3 }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
242
242
  ensure
243
243
  Thrift.type_checking = false
244
244
  end
245
- lambda { hello.greeting = 3 }.should_not raise_error(Thrift::TypeError)
245
+ expect { hello.greeting = 3 }.not_to raise_error
246
246
  end
247
247
 
248
248
  it "should raise an exception when unknown types are given to Thrift::Struct.new" do
249
- lambda { SpecNamespace::Hello.new(:fish => 'salmon') }.should raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
249
+ expect { SpecNamespace::Hello.new(:fish => 'salmon') }.to raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
250
250
  end
251
251
 
252
252
  it "should support `raise Xception, 'message'` for Exception structs" do
253
253
  begin
254
254
  raise SpecNamespace::Xception, "something happened"
255
255
  rescue Thrift::Exception => e
256
- e.message.should == "something happened"
257
- e.code.should == 1
256
+ expect(e.message).to eq("something happened")
257
+ expect(e.code).to eq(1)
258
258
  # ensure it gets serialized properly, this is the really important part
259
- prot = Thrift::BaseProtocol.new(mock("trans"))
260
- prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception")
261
- prot.should_receive(:write_struct_end)
262
- prot.should_receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
263
- prot.should_receive(:write_string).with("something happened")
264
- prot.should_receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
265
- prot.should_receive(:write_i32).with(1)
266
- prot.should_receive(:write_field_stop)
267
- prot.should_receive(:write_field_end).twice
259
+ prot = Thrift::BaseProtocol.new(double("trans"))
260
+ expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
261
+ expect(prot).to receive(:write_struct_end)
262
+ expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
263
+ expect(prot).to receive(:write_string).with("something happened")
264
+ expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
265
+ expect(prot).to receive(:write_i32).with(1)
266
+ expect(prot).to receive(:write_field_stop)
267
+ expect(prot).to receive(:write_field_end).twice
268
268
 
269
269
  e.write(prot)
270
270
  end
@@ -274,17 +274,17 @@ describe 'Struct' do
274
274
  begin
275
275
  raise SpecNamespace::Xception, :message => "something happened", :code => 5
276
276
  rescue Thrift::Exception => e
277
- e.message.should == "something happened"
278
- e.code.should == 5
279
- prot = Thrift::BaseProtocol.new(mock("trans"))
280
- prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception")
281
- prot.should_receive(:write_struct_end)
282
- prot.should_receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
283
- prot.should_receive(:write_string).with("something happened")
284
- prot.should_receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
285
- prot.should_receive(:write_i32).with(5)
286
- prot.should_receive(:write_field_stop)
287
- prot.should_receive(:write_field_end).twice
277
+ expect(e.message).to eq("something happened")
278
+ expect(e.code).to eq(5)
279
+ prot = Thrift::BaseProtocol.new(double("trans"))
280
+ expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
281
+ expect(prot).to receive(:write_struct_end)
282
+ expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
283
+ expect(prot).to receive(:write_string).with("something happened")
284
+ expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
285
+ expect(prot).to receive(:write_i32).with(5)
286
+ expect(prot).to receive(:write_field_stop)
287
+ expect(prot).to receive(:write_field_end).twice
288
288
 
289
289
  e.write(prot)
290
290
  end