upfluence-thrift 2.6.8 → 2.7.4

data/spec/struct_spec.rb

@@ -25,7 +25,7 @@ describe 'Struct' do
     it "should iterate over all fields properly" do
       fields = {}
       SpecNamespace::Foo.new.each_field { |fid,field_info| fields[fid] = field_info }
-      fields.should == SpecNamespace::Foo::FIELDS
+      expect(fields).to eq(SpecNamespace::Foo::FIELDS)
     end
 
     it "should initialize all fields to defaults" do
@@ -39,19 +39,19 @@ describe 'Struct' do
     end
 
     def validate_default_arguments(object)
-      object.simple.should == 53
-      object.words.should == "words"
-      object.hello.should == SpecNamespace::Hello.new(:greeting => 'hello, world!')
-      object.ints.should == [1, 2, 2, 3]
-      object.complex.should be_nil
-      object.shorts.should == Set.new([5, 17, 239])
+      expect(object.simple).to eq(53)
+      expect(object.words).to eq("words")
+      expect(object.hello).to eq(SpecNamespace::Hello.new(:greeting => 'hello, world!'))
+      expect(object.ints).to eq([1, 2, 2, 3])
+      expect(object.complex).to be_nil
+      expect(object.shorts).to eq(Set.new([5, 17, 239]))
     end
 
     it "should not share default values between instances" do
       begin
         struct = SpecNamespace::Foo.new
         struct.ints << 17
-        SpecNamespace::Foo.new.ints.should == [1,2,2,3]
+        expect(SpecNamespace::Foo.new.ints).to eq([1,2,2,3])
       ensure
         # ensure no leakage to other tests
         SpecNamespace::Foo::FIELDS[4][:default] = [1,2,2,3]
@@ -60,48 +60,48 @@ describe 'Struct' do
 
     it "should properly initialize boolean values" do
       struct = SpecNamespace::BoolStruct.new(:yesno => false)
-      struct.yesno.should be_false
+      expect(struct.yesno).to be_falsey
     end
 
     it "should have proper == semantics" do
-      SpecNamespace::Foo.new.should_not == SpecNamespace::Hello.new
-      SpecNamespace::Foo.new.should == SpecNamespace::Foo.new
-      SpecNamespace::Foo.new(:simple => 52).should_not == SpecNamespace::Foo.new
+      expect(SpecNamespace::Foo.new).not_to eq(SpecNamespace::Hello.new)
+      expect(SpecNamespace::Foo.new).to eq(SpecNamespace::Foo.new)
+      expect(SpecNamespace::Foo.new(:simple => 52)).not_to eq(SpecNamespace::Foo.new)
     end
 
     it "should print enum value names in inspect" do
-      SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect.should == "<SpecNamespace::StructWithSomeEnum some_enum:ONE (0)>"
+      expect(SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect).to eq("<SpecNamespace::StructWithSomeEnum some_enum:ONE (0)>")
 
-      SpecNamespace::StructWithEnumMap.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect.should == "<SpecNamespace::StructWithEnumMap my_map:{ONE (0): [TWO (1)]}>"
+      expect(SpecNamespace::StructWithEnumMap.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect).to eq("<SpecNamespace::StructWithEnumMap my_map:{ONE (0): [TWO (1)]}>")
     end
 
     it "should pretty print binary fields" do
-      SpecNamespace::Foo2.new(:my_binary => "\001\002\003").inspect.should == "<SpecNamespace::Foo2 my_binary:010203>"
+      expect(SpecNamespace::Foo2.new(:my_binary => "\001\002\003").inspect).to eq("<SpecNamespace::Foo2 my_binary:010203>")
     end
 
     it "should offer field? methods" do
-      SpecNamespace::Foo.new.opt_string?.should be_false
-      SpecNamespace::Foo.new(:simple => 52).simple?.should be_true
-      SpecNamespace::Foo.new(:my_bool => false).my_bool?.should be_true
-      SpecNamespace::Foo.new(:my_bool => true).my_bool?.should be_true
+      expect(SpecNamespace::Foo.new.opt_string?).to be_falsey
+      expect(SpecNamespace::Foo.new(:simple => 52).simple?).to be_truthy
+      expect(SpecNamespace::Foo.new(:my_bool => false).my_bool?).to be_truthy
+      expect(SpecNamespace::Foo.new(:my_bool => true).my_bool?).to be_truthy
     end
 
     it "should be comparable" do
       s1 = SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE)
       s2 = SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::TWO)
 
-      (s1 <=> s2).should == -1
-      (s2 <=> s1).should == 1
-      (s1 <=> s1).should == 0
-      (s1 <=> SpecNamespace::StructWithSomeEnum.new()).should == -1
+      expect(s1 <=> s2).to eq(-1)
+      expect(s2 <=> s1).to eq(1)
+      expect(s1 <=> s1).to eq(0)
+      expect(s1 <=> SpecNamespace::StructWithSomeEnum.new()).to eq(-1)
     end
 
     it "should read itself off the wire" do
       struct = SpecNamespace::Foo.new
-      prot = Thrift::BaseProtocol.new(mock("transport"))
-      prot.should_receive(:read_struct_begin).twice
-      prot.should_receive(:read_struct_end).twice
-      prot.should_receive(:read_field_begin).and_return(
+      prot = Thrift::BaseProtocol.new(double("transport"))
+      expect(prot).to receive(:read_struct_begin).twice
+      expect(prot).to receive(:read_struct_end).twice
+      expect(prot).to receive(:read_field_begin).and_return(
         ['complex', Thrift::Types::MAP, 5], # Foo
         ['words', Thrift::Types::STRING, 2], # Foo
         ['hello', Thrift::Types::STRUCT, 3], # Foo
@@ -112,49 +112,49 @@ describe 'Struct' do
         ['shorts', Thrift::Types::SET, 6], # Foo
         [nil, Thrift::Types::STOP, 0] # Hello
       )
-      prot.should_receive(:read_field_end).exactly(7).times
-      prot.should_receive(:read_map_begin).and_return(
+      expect(prot).to receive(:read_field_end).exactly(7).times
+      expect(prot).to receive(:read_map_begin).and_return(
         [Thrift::Types::I32, Thrift::Types::MAP, 2], # complex
           [Thrift::Types::STRING, Thrift::Types::DOUBLE, 2], # complex/1/value
           [Thrift::Types::STRING, Thrift::Types::DOUBLE, 1] # complex/2/value
       )
-      prot.should_receive(:read_map_end).exactly(3).times
-      prot.should_receive(:read_list_begin).and_return([Thrift::Types::I32, 4])
-      prot.should_receive(:read_list_end)
-      prot.should_receive(:read_set_begin).and_return([Thrift::Types::I16, 2])
-      prot.should_receive(:read_set_end)
-      prot.should_receive(:read_i32).and_return(
+      expect(prot).to receive(:read_map_end).exactly(3).times
+      expect(prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, 4])
+      expect(prot).to receive(:read_list_end)
+      expect(prot).to receive(:read_set_begin).and_return([Thrift::Types::I16, 2])
+      expect(prot).to receive(:read_set_end)
+      expect(prot).to receive(:read_i32).and_return(
         1, 14,        # complex keys
         42,           # simple
         4, 23, 4, 29  # ints
       )
-      prot.should_receive(:read_string).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?")
-      prot.should_receive(:read_double).and_return(Math::PI, Math::E, 4.669201609)
-      prot.should_receive(:read_i16).and_return(2, 3)
-      prot.should_not_receive(:skip)
+      expect(prot).to receive(:read_string).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?")
+      expect(prot).to receive(:read_double).and_return(Math::PI, Math::E, 4.669201609)
+      expect(prot).to receive(:read_i16).and_return(2, 3)
+      expect(prot).not_to receive(:skip)
       struct.read(prot)
 
-      struct.simple.should == 42
-      struct.complex.should == {1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}}
-      struct.hello.should == SpecNamespace::Hello.new(:greeting => "what's up?")
-      struct.words.should == "apple banana"
-      struct.ints.should == [4, 23, 4, 29]
-      struct.shorts.should == Set.new([3, 2])
+      expect(struct.simple).to eq(42)
+      expect(struct.complex).to eq({1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}})
+      expect(struct.hello).to eq(SpecNamespace::Hello.new(:greeting => "what's up?"))
+      expect(struct.words).to eq("apple banana")
+      expect(struct.ints).to eq([4, 23, 4, 29])
+      expect(struct.shorts).to eq(Set.new([3, 2]))
     end
 
     it "should serialize false boolean fields correctly" do
       b = SpecNamespace::BoolStruct.new(:yesno => false)
       prot = Thrift::BinaryProtocol.new(Thrift::MemoryBufferTransport.new)
-      prot.should_receive(:write_bool).with(false)
+      expect(prot).to receive(:write_bool).with(false)
       b.write(prot)
     end
 
     it "should skip unexpected fields in structs and use default values" do
       struct = SpecNamespace::Foo.new
-      prot = Thrift::BaseProtocol.new(mock("transport"))
-      prot.should_receive(:read_struct_begin)
-      prot.should_receive(:read_struct_end)
-      prot.should_receive(:read_field_begin).and_return(
+      prot = Thrift::BaseProtocol.new(double("transport"))
+      expect(prot).to receive(:read_struct_begin)
+      expect(prot).to receive(:read_struct_end)
+      expect(prot).to receive(:read_field_begin).and_return(
         ['simple', Thrift::Types::I32, 1],
         ['complex', Thrift::Types::STRUCT, 5],
         ['thinz', Thrift::Types::MAP, 7],
@@ -162,55 +162,55 @@ describe 'Struct' do
         ['words', Thrift::Types::STRING, 2],
         [nil, Thrift::Types::STOP, 0]
       )
-      prot.should_receive(:read_field_end).exactly(5).times
-      prot.should_receive(:read_i32).and_return(42)
-      prot.should_receive(:read_string).and_return("foobar")
-      prot.should_receive(:skip).with(Thrift::Types::STRUCT)
-      prot.should_receive(:skip).with(Thrift::Types::MAP)
+      expect(prot).to receive(:read_field_end).exactly(5).times
+      expect(prot).to receive(:read_i32).and_return(42)
+      expect(prot).to receive(:read_string).and_return("foobar")
+      expect(prot).to receive(:skip).with(Thrift::Types::STRUCT)
+      expect(prot).to receive(:skip).with(Thrift::Types::MAP)
       # prot.should_receive(:read_map_begin).and_return([Thrift::Types::I32, Thrift::Types::I32, 0])
       # prot.should_receive(:read_map_end)
-      prot.should_receive(:skip).with(Thrift::Types::I32)
+      expect(prot).to receive(:skip).with(Thrift::Types::I32)
       struct.read(prot)
 
-      struct.simple.should == 42
-      struct.complex.should be_nil
-      struct.words.should == "foobar"
-      struct.hello.should == SpecNamespace::Hello.new(:greeting => 'hello, world!')
-      struct.ints.should == [1, 2, 2, 3]
-      struct.shorts.should == Set.new([5, 17, 239])
+      expect(struct.simple).to eq(42)
+      expect(struct.complex).to be_nil
+      expect(struct.words).to eq("foobar")
+      expect(struct.hello).to eq(SpecNamespace::Hello.new(:greeting => 'hello, world!'))
+      expect(struct.ints).to eq([1, 2, 2, 3])
+      expect(struct.shorts).to eq(Set.new([5, 17, 239]))
     end
 
     it "should write itself to the wire" do
-      prot = Thrift::BaseProtocol.new(mock("transport")) #mock("Protocol")
-      prot.should_receive(:write_struct_begin).with("SpecNamespace::Foo")
-      prot.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
-      prot.should_receive(:write_struct_end).twice
-      prot.should_receive(:write_field_begin).with('ints', Thrift::Types::LIST, 4)
-      prot.should_receive(:write_i32).with(1)
-      prot.should_receive(:write_i32).with(2).twice
-      prot.should_receive(:write_i32).with(3)
-      prot.should_receive(:write_field_begin).with('complex', Thrift::Types::MAP, 5)
-      prot.should_receive(:write_i32).with(5)
-      prot.should_receive(:write_string).with('foo')
-      prot.should_receive(:write_double).with(1.23)
-      prot.should_receive(:write_field_begin).with('shorts', Thrift::Types::SET, 6)
-      prot.should_receive(:write_i16).with(5)
-      prot.should_receive(:write_i16).with(17)
-      prot.should_receive(:write_i16).with(239)
-      prot.should_receive(:write_field_stop).twice
-      prot.should_receive(:write_field_end).exactly(6).times
-      prot.should_receive(:write_field_begin).with('simple', Thrift::Types::I32, 1)
-      prot.should_receive(:write_i32).with(53)
-      prot.should_receive(:write_field_begin).with('hello', Thrift::Types::STRUCT, 3)
-      prot.should_receive(:write_field_begin).with('greeting', Thrift::Types::STRING, 1)
-      prot.should_receive(:write_string).with('hello, world!')
-      prot.should_receive(:write_map_begin).with(Thrift::Types::I32, Thrift::Types::MAP, 1)
-      prot.should_receive(:write_map_begin).with(Thrift::Types::STRING, Thrift::Types::DOUBLE, 1)
-      prot.should_receive(:write_map_end).twice
-      prot.should_receive(:write_list_begin).with(Thrift::Types::I32, 4)
-      prot.should_receive(:write_list_end)
-      prot.should_receive(:write_set_begin).with(Thrift::Types::I16, 3)
-      prot.should_receive(:write_set_end)
+      prot = Thrift::BaseProtocol.new(double("transport")) #mock("Protocol")
+      expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Foo")
+      expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Hello")
+      expect(prot).to receive(:write_struct_end).twice
+      expect(prot).to receive(:write_field_begin).with('ints', Thrift::Types::LIST, 4)
+      expect(prot).to receive(:write_i32).with(1)
+      expect(prot).to receive(:write_i32).with(2).twice
+      expect(prot).to receive(:write_i32).with(3)
+      expect(prot).to receive(:write_field_begin).with('complex', Thrift::Types::MAP, 5)
+      expect(prot).to receive(:write_i32).with(5)
+      expect(prot).to receive(:write_string).with('foo')
+      expect(prot).to receive(:write_double).with(1.23)
+      expect(prot).to receive(:write_field_begin).with('shorts', Thrift::Types::SET, 6)
+      expect(prot).to receive(:write_i16).with(5)
+      expect(prot).to receive(:write_i16).with(17)
+      expect(prot).to receive(:write_i16).with(239)
+      expect(prot).to receive(:write_field_stop).twice
+      expect(prot).to receive(:write_field_end).exactly(6).times
+      expect(prot).to receive(:write_field_begin).with('simple', Thrift::Types::I32, 1)
+      expect(prot).to receive(:write_i32).with(53)
+      expect(prot).to receive(:write_field_begin).with('hello', Thrift::Types::STRUCT, 3)
+      expect(prot).to receive(:write_field_begin).with('greeting', Thrift::Types::STRING, 1)
+      expect(prot).to receive(:write_string).with('hello, world!')
+      expect(prot).to receive(:write_map_begin).with(Thrift::Types::I32, Thrift::Types::MAP, 1)
+      expect(prot).to receive(:write_map_begin).with(Thrift::Types::STRING, Thrift::Types::DOUBLE, 1)
+      expect(prot).to receive(:write_map_end).twice
+      expect(prot).to receive(:write_list_begin).with(Thrift::Types::I32, 4)
+      expect(prot).to receive(:write_list_end)
+      expect(prot).to receive(:write_set_begin).with(Thrift::Types::I16, 3)
+      expect(prot).to receive(:write_set_end)
 
       struct = SpecNamespace::Foo.new
       struct.words = nil
@@ -221,50 +221,50 @@ describe 'Struct' do
     it "should raise an exception if presented with an unknown container" do
       # yeah this is silly, but I'm going for code coverage here
       struct = SpecNamespace::Foo.new
-      lambda { struct.send :write_container, nil, nil, {:type => "foo"} }.should raise_error(StandardError, "Not a container type: foo")
+      expect { struct.send :write_container, nil, nil, {:type => "foo"} }.to raise_error(StandardError, "Not a container type: foo")
     end
 
     it "should support optional type-checking in Thrift::Struct.new" do
       Thrift.type_checking = true
       begin
-        lambda { SpecNamespace::Hello.new(:greeting => 3) }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Integer for field greeting")
+        expect { SpecNamespace::Hello.new(:greeting => 3) }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
       ensure
         Thrift.type_checking = false
       end
-      lambda { SpecNamespace::Hello.new(:greeting => 3) }.should_not raise_error(Thrift::TypeError)
+      expect { SpecNamespace::Hello.new(:greeting => 3) }.not_to raise_error
     end
 
     it "should support optional type-checking in field accessors" do
       Thrift.type_checking = true
       begin
         hello = SpecNamespace::Hello.new
-        lambda { hello.greeting = 3 }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Integer for field greeting")
+        expect { hello.greeting = 3 }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
       ensure
         Thrift.type_checking = false
       end
-      lambda { hello.greeting = 3 }.should_not raise_error(Thrift::TypeError)
+      expect { hello.greeting = 3 }.not_to raise_error
     end
 
     it "should raise an exception when unknown types are given to Thrift::Struct.new" do
-      lambda { SpecNamespace::Hello.new(:fish => 'salmon') }.should raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
+      expect { SpecNamespace::Hello.new(:fish => 'salmon') }.to raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
     end
 
     it "should support `raise Xception, 'message'` for Exception structs" do
       begin
         raise SpecNamespace::Xception, "something happened"
       rescue Thrift::Exception => e
-        e.message.should == "something happened"
-        e.code.should == 1
+        expect(e.message).to eq("something happened")
+        expect(e.code).to eq(1)
         # ensure it gets serialized properly, this is the really important part
-        prot = Thrift::BaseProtocol.new(mock("trans"))
-        prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception")
-        prot.should_receive(:write_struct_end)
-        prot.should_receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
-        prot.should_receive(:write_string).with("something happened")
-        prot.should_receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
-        prot.should_receive(:write_i32).with(1)
-        prot.should_receive(:write_field_stop)
-        prot.should_receive(:write_field_end).twice
+        prot = Thrift::BaseProtocol.new(double("trans"))
+        expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
+        expect(prot).to receive(:write_struct_end)
+        expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
+        expect(prot).to receive(:write_string).with("something happened")
+        expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
+        expect(prot).to receive(:write_i32).with(1)
+        expect(prot).to receive(:write_field_stop)
+        expect(prot).to receive(:write_field_end).twice
 
         e.write(prot)
       end
@@ -274,17 +274,17 @@ describe 'Struct' do
       begin
         raise SpecNamespace::Xception, :message => "something happened", :code => 5
       rescue Thrift::Exception => e
-        e.message.should == "something happened"
-        e.code.should == 5
-        prot = Thrift::BaseProtocol.new(mock("trans"))
-        prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception")
-        prot.should_receive(:write_struct_end)
-        prot.should_receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
-        prot.should_receive(:write_string).with("something happened")
-        prot.should_receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
-        prot.should_receive(:write_i32).with(5)
-        prot.should_receive(:write_field_stop)
-        prot.should_receive(:write_field_end).twice
+        expect(e.message).to eq("something happened")
+        expect(e.code).to eq(5)
+        prot = Thrift::BaseProtocol.new(double("trans"))
+        expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
+        expect(prot).to receive(:write_struct_end)
+        expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
+        expect(prot).to receive(:write_string).with("something happened")
+        expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
+        expect(prot).to receive(:write_i32).with(5)
+        expect(prot).to receive(:write_field_stop)
+        expect(prot).to receive(:write_field_end).twice
 
         e.write(prot)
       end

data/spec/thin_http_server_spec.rb

@@ -23,64 +23,107 @@ require 'thrift/server/thin_http_server'
 require 'thrift/server/rack_application'
 
 describe Thrift::ThinHTTPServer do
+  let(:processor) { double('processor') }
 
-  let(:processor) { mock('processor') }
-
-  describe "#initialize" do
-
-    context "when using the defaults" do
-
+  describe '#initialize' do
+    context 'when using the defaults' do
       it "binds to port 80, with host 0.0.0.0, a path of '/'" do
-        Thin::Server.should_receive(:new).with('0.0.0.0', 80, an_instance_of(Rack::Builder))
+        expect(Thin::Server).to receive(:new).with('0.0.0.0', 80, an_instance_of(Rack::Builder))
         Thrift::ThinHTTPServer.new(processor)
       end
 
       it 'creates a ThinHTTPServer::RackApplicationContext' do
-        Thrift::RackApplication.should_receive(:for).with("/", processor, an_instance_of(Thrift::BinaryProtocolFactory)).and_return(anything)
+        expect(Thrift::RackApplication).to receive(:for).with('/', processor,
+                                                              an_instance_of(Thrift::BinaryProtocolFactory)).and_return(anything)
         Thrift::ThinHTTPServer.new(processor)
       end
 
-      it "uses the BinaryProtocolFactory" do
-        Thrift::BinaryProtocolFactory.should_receive(:new)
+      it 'uses the BinaryProtocolFactory' do
+        expect(Thrift::BinaryProtocolFactory).to receive(:new)
         Thrift::ThinHTTPServer.new(processor)
       end
-
     end
 
-    context "when using the options" do
-
+    context 'when using the options' do
       it 'accepts :ip, :port, :path' do
-        ip = "192.168.0.1"
+        ip = '192.168.0.1'
         port = 3000
-        path = "/thin"
-        Thin::Server.should_receive(:new).with(ip, port, an_instance_of(Rack::Builder))
+        path = '/thin'
+        expect(Thin::Server).to receive(:new).with(ip, port, an_instance_of(Rack::Builder))
         Thrift::ThinHTTPServer.new(processor,
-                           :ip => ip,
-                           :port => port,
-                           :path => path)
+                                   ip:   ip,
+                                   port: port,
+                                   path: path)
       end
 
       it 'creates a ThinHTTPServer::RackApplicationContext with a different protocol factory' do
-        Thrift::RackApplication.should_receive(:for).with("/", processor, an_instance_of(Thrift::JsonProtocolFactory)).and_return(anything)
+        expect(Thrift::RackApplication).to receive(:for).with('/', processor,
+                                                              an_instance_of(Thrift::JsonProtocolFactory)).and_return(anything)
         Thrift::ThinHTTPServer.new(processor,
-                           :protocol_factory => Thrift::JsonProtocolFactory.new)
+                                   protocol_factory: Thrift::JsonProtocolFactory.new)
       end
-
     end
-
   end
 
-  describe "#serve" do
-
+  describe '#serve' do
     it 'starts the Thin server' do
-      underlying_thin_server = mock('thin server', :start => true)
-      Thin::Server.stub(:new).and_return(underlying_thin_server)
+      underlying_thin_server = double('thin server', start: true)
+      allow(Thin::Server).to receive(:new).and_return(underlying_thin_server)
 
       thin_thrift_server = Thrift::ThinHTTPServer.new(processor)
 
-      underlying_thin_server.should_receive(:start)
+      expect(underlying_thin_server).to receive(:start)
       thin_thrift_server.serve
     end
   end
+end
+
+describe Thrift::RackApplication do
+  include Rack::Test::Methods
+
+  let(:processor) { double('processor') }
+  let(:protocol_factory) { double('protocol factory') }
+
+  def app
+    Thrift::RackApplication.for('/', processor, protocol_factory)
+  end
+
+  context '404 response' do
+    it 'receives a non-POST' do
+      header('Content-Type', 'application/x-thrift')
+      get '/'
+      expect(last_response.status).to be 404
+    end
+
+    it 'receives a header other than application/x-thrift' do
+      header('Content-Type', 'application/json')
+      post '/'
+      expect(last_response.status).to be 404
+    end
+  end
+
+  context '200 response' do
+    before do
+      allow(protocol_factory).to receive(:get_protocol)
+      allow(processor).to receive(:process)
+    end
 
+    it 'creates an IOStreamTransport' do
+      header('Content-Type', 'application/x-thrift')
+      expect(Thrift::IOStreamTransport).to receive(:new).with(an_instance_of(StringIO), an_instance_of(Rack::Response))
+      post '/'
+    end
+
+    it 'fetches the right protocol based on the Transport' do
+      header('Content-Type', 'application/x-thrift')
+      expect(protocol_factory).to receive(:get_protocol).with(an_instance_of(Thrift::IOStreamTransport))
+      post '/'
+    end
+
+    it 'status code 200' do
+      header('Content-Type', 'application/x-thrift')
+      post '/'
+      expect(last_response.ok?).to be_truthy
+    end
+  end
 end

data/spec/{gen-rb/thrift_spec_constants.rb → thrift_spec_constants.rb}

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

data/spec/{gen-rb/thrift_spec_types.rb → thrift_spec_types.rb}

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
@@ -201,11 +201,11 @@ module SpecNamespace
 
     FIELDS = {
       # A doc string
-      THRIFT_FIELD_INDEX_STRING_FIELD => {type: ::Thrift::Types::STRING, name: 'string_field', legacy_annotations: THRIFT_FIELD_STRING_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_STRING_FIELD_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_I32_FIELD => {type: ::Thrift::Types::I32, name: 'i32_field', legacy_annotations: THRIFT_FIELD_I32_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_I32_FIELD_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_OTHER_I32_FIELD => {type: ::Thrift::Types::I32, name: 'other_i32_field', legacy_annotations: THRIFT_FIELD_OTHER_I32_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_OTHER_I32_FIELD_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_ENUM_FIELD => {type: ::Thrift::Types::I32, name: 'enum_field', enum_class: ::SpecNamespace::SomeEnum, legacy_annotations: THRIFT_FIELD_ENUM_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_ENUM_FIELD_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_BINARY_FIELD => {type: ::Thrift::Types::STRING, name: 'binary_field', binary: true, legacy_annotations: THRIFT_FIELD_BINARY_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_BINARY_FIELD_STRUCTURED_ANNOTATIONS}
+      THRIFT_FIELD_INDEX_STRING_FIELD => {type: ::Thrift::Types::STRING, name: 'string_field', optional: true, legacy_annotations: THRIFT_FIELD_STRING_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_STRING_FIELD_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_I32_FIELD => {type: ::Thrift::Types::I32, name: 'i32_field', optional: true, legacy_annotations: THRIFT_FIELD_I32_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_I32_FIELD_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_OTHER_I32_FIELD => {type: ::Thrift::Types::I32, name: 'other_i32_field', optional: true, legacy_annotations: THRIFT_FIELD_OTHER_I32_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_OTHER_I32_FIELD_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_ENUM_FIELD => {type: ::Thrift::Types::I32, name: 'enum_field', optional: true, enum_class: ::SpecNamespace::SomeEnum, legacy_annotations: THRIFT_FIELD_ENUM_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_ENUM_FIELD_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_BINARY_FIELD => {type: ::Thrift::Types::STRING, name: 'binary_field', binary: true, optional: true, legacy_annotations: THRIFT_FIELD_BINARY_FIELD_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_BINARY_FIELD_STRUCTURED_ANNOTATIONS}
     }
 
     def struct_fields; FIELDS; end
@@ -667,16 +667,16 @@ module SpecNamespace
     ].freeze
 
     FIELDS = {
-      THRIFT_FIELD_INDEX_IM_TRUE => {type: ::Thrift::Types::BOOL, name: 'im_true', legacy_annotations: THRIFT_FIELD_IM_TRUE_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_IM_TRUE_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_A_BITE => {type: ::Thrift::Types::BYTE, name: 'a_bite', legacy_annotations: THRIFT_FIELD_A_BITE_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_A_BITE_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_INTEGER16 => {type: ::Thrift::Types::I16, name: 'integer16', legacy_annotations: THRIFT_FIELD_INTEGER16_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_INTEGER16_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_INTEGER32 => {type: ::Thrift::Types::I32, name: 'integer32', legacy_annotations: THRIFT_FIELD_INTEGER32_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_INTEGER32_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_INTEGER64 => {type: ::Thrift::Types::I64, name: 'integer64', legacy_annotations: THRIFT_FIELD_INTEGER64_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_INTEGER64_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_DOUBLE_PRECISION => {type: ::Thrift::Types::DOUBLE, name: 'double_precision', legacy_annotations: THRIFT_FIELD_DOUBLE_PRECISION_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_DOUBLE_PRECISION_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_SOME_CHARACTERS => {type: ::Thrift::Types::STRING, name: 'some_characters', legacy_annotations: THRIFT_FIELD_SOME_CHARACTERS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_SOME_CHARACTERS_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_OTHER_I32 => {type: ::Thrift::Types::I32, name: 'other_i32', legacy_annotations: THRIFT_FIELD_OTHER_I32_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_OTHER_I32_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_SOME_ENUM => {type: ::Thrift::Types::I32, name: 'some_enum', enum_class: ::SpecNamespace::SomeEnum, legacy_annotations: THRIFT_FIELD_SOME_ENUM_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_SOME_ENUM_STRUCTURED_ANNOTATIONS},
-      THRIFT_FIELD_INDEX_MY_MAP => {type: ::Thrift::Types::MAP, name: 'my_map', key: {type: ::Thrift::Types::I32, enum_class: ::SpecNamespace::SomeEnum}, value: {type: ::Thrift::Types::LIST, element: {type: ::Thrift::Types::I32, enum_class: ::SpecNamespace::SomeEnum}}, legacy_annotations: THRIFT_FIELD_MY_MAP_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_MY_MAP_STRUCTURED_ANNOTATIONS}
+      THRIFT_FIELD_INDEX_IM_TRUE => {type: ::Thrift::Types::BOOL, name: 'im_true', optional: true, legacy_annotations: THRIFT_FIELD_IM_TRUE_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_IM_TRUE_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_A_BITE => {type: ::Thrift::Types::BYTE, name: 'a_bite', optional: true, legacy_annotations: THRIFT_FIELD_A_BITE_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_A_BITE_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_INTEGER16 => {type: ::Thrift::Types::I16, name: 'integer16', optional: true, legacy_annotations: THRIFT_FIELD_INTEGER16_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_INTEGER16_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_INTEGER32 => {type: ::Thrift::Types::I32, name: 'integer32', optional: true, legacy_annotations: THRIFT_FIELD_INTEGER32_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_INTEGER32_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_INTEGER64 => {type: ::Thrift::Types::I64, name: 'integer64', optional: true, legacy_annotations: THRIFT_FIELD_INTEGER64_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_INTEGER64_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_DOUBLE_PRECISION => {type: ::Thrift::Types::DOUBLE, name: 'double_precision', optional: true, legacy_annotations: THRIFT_FIELD_DOUBLE_PRECISION_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_DOUBLE_PRECISION_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_SOME_CHARACTERS => {type: ::Thrift::Types::STRING, name: 'some_characters', optional: true, legacy_annotations: THRIFT_FIELD_SOME_CHARACTERS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_SOME_CHARACTERS_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_OTHER_I32 => {type: ::Thrift::Types::I32, name: 'other_i32', optional: true, legacy_annotations: THRIFT_FIELD_OTHER_I32_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_OTHER_I32_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_SOME_ENUM => {type: ::Thrift::Types::I32, name: 'some_enum', optional: true, enum_class: ::SpecNamespace::SomeEnum, legacy_annotations: THRIFT_FIELD_SOME_ENUM_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_SOME_ENUM_STRUCTURED_ANNOTATIONS},
+      THRIFT_FIELD_INDEX_MY_MAP => {type: ::Thrift::Types::MAP, name: 'my_map', key: {type: ::Thrift::Types::I32, enum_class: ::SpecNamespace::SomeEnum}, value: {type: ::Thrift::Types::LIST, element: {type: ::Thrift::Types::I32, enum_class: ::SpecNamespace::SomeEnum}}, optional: true, legacy_annotations: THRIFT_FIELD_MY_MAP_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_MY_MAP_STRUCTURED_ANNOTATIONS}
     }
 
     def struct_fields; FIELDS; end

data/spec/types/known/any_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
-require 'thrift/types/value'
-require 'thrift/types/known/any'
+require 'thrift/types/value/value'
+require 'thrift/types/known/any/any'
 
 describe 'Thrift::Types::Known::Any' do
   describe 'encode' do

data/spec/types/known/duration_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'thrift/types/known/duration'
+require 'thrift/types/known/duration/duration'
 
 describe 'Thrift::Types::Known::Duration' do
   context 'from_number' do

data/spec/types/known/timestamp_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'thrift/types/known/timestamp'
+require 'thrift/types/known/timestamp/timestamp'
 
 describe 'Thrift::Types::Known::Timestamp' do
   context 'from_time' do

data/spec/types/value_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'json'
-require 'thrift/types/value'
+require 'thrift/types/value/value'
+
 
 class LocalObject
   def initialize(foo, bar)