thrift 0.8.0 → 0.9.0

data/spec/types_spec.rb

@@ -17,10 +17,9 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftTypesSpec < Spec::ExampleGroup
-  include Thrift
+describe Thrift::Types do
 
   before(:each) do
     Thrift.type_checking = true
@@ -30,87 +29,87 @@ class ThriftTypesSpec < Spec::ExampleGroup
     Thrift.type_checking = false
   end
 
-  describe "Type checking" do
+  context 'type checking' do
     it "should return the proper name for each type" do
-      Thrift.type_name(Types::I16).should == "Types::I16"
-      Thrift.type_name(Types::VOID).should == "Types::VOID"
-      Thrift.type_name(Types::LIST).should == "Types::LIST"
+      Thrift.type_name(Thrift::Types::I16).should == "Types::I16"
+      Thrift.type_name(Thrift::Types::VOID).should == "Types::VOID"
+      Thrift.type_name(Thrift::Types::LIST).should == "Types::LIST"
       Thrift.type_name(42).should be_nil
     end
 
     it "should check types properly" do
-      # lambda { Thrift.check_type(nil, Types::STOP) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(3,              {:type => Types::STOP},   :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil,            {:type => Types::VOID},   :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(3,              {:type => Types::VOID},   :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(true,           {:type => Types::BOOL},   :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(3,              {:type => Types::BOOL},   :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(42,             {:type => Types::BYTE},   :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(42,             {:type => Types::I16},    :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(42,             {:type => Types::I32},    :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(42,             {:type => Types::I64},    :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(3.14,           {:type => Types::I32},    :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(3.14,           {:type => Types::DOUBLE}, :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(3,              {:type => Types::DOUBLE}, :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type("3",            {:type => Types::STRING}, :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(3,              {:type => Types::STRING}, :foo) }.should raise_error(TypeError)
+      # lambda { Thrift.check_type(nil, Thrift::Types::STOP) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3,              {:type => Thrift::Types::STOP},   :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil,            {:type => Thrift::Types::VOID},   :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3,              {:type => Thrift::Types::VOID},   :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(true,           {:type => Thrift::Types::BOOL},   :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3,              {:type => Thrift::Types::BOOL},   :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(42,             {:type => Thrift::Types::BYTE},   :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(42,             {:type => Thrift::Types::I16},    :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(42,             {:type => Thrift::Types::I32},    :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(42,             {:type => Thrift::Types::I64},    :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3.14,           {:type => Thrift::Types::I32},    :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3.14,           {:type => Thrift::Types::DOUBLE}, :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3,              {:type => Thrift::Types::DOUBLE}, :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type("3",            {:type => Thrift::Types::STRING}, :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(3,              {:type => Thrift::Types::STRING}, :foo) }.should raise_error(Thrift::TypeError)
       hello = SpecNamespace::Hello.new
-      lambda { Thrift.check_type(hello,          {:type => Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type("foo",          {:type => Types::STRUCT}, :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type({:foo => 1},    {:type => Types::MAP},    :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type([1],            {:type => Types::MAP},    :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type([1],            {:type => Types::LIST},   :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type({:foo => 1},    {:type => Types::LIST},   :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(Set.new([1,2]), {:type => Types::SET},    :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type([1,2],          {:type => Types::SET},    :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type({:foo => true}, {:type => Types::SET},    :foo) }.should raise_error(TypeError)
+      lambda { Thrift.check_type(hello,          {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type("foo",          {:type => Thrift::Types::STRUCT}, :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type({:foo => 1},    {:type => Thrift::Types::MAP},    :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type([1],            {:type => Thrift::Types::MAP},    :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type([1],            {:type => Thrift::Types::LIST},   :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type({:foo => 1},    {:type => Thrift::Types::LIST},   :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(Set.new([1,2]), {:type => Thrift::Types::SET},    :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type([1,2],          {:type => Thrift::Types::SET},    :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type({:foo => true}, {:type => Thrift::Types::SET},    :foo) }.should raise_error(Thrift::TypeError)
     end
 
     it "should error out if nil is passed and skip_types is false" do
-      lambda { Thrift.check_type(nil, {:type => Types::BOOL},   :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::BYTE},   :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::I16},    :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::I32},    :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::I64},    :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::DOUBLE}, :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::STRING}, :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::STRUCT}, :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::LIST},   :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::SET},    :foo, false) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(nil, {:type => Types::MAP},    :foo, false) }.should raise_error(TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::BOOL},   :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::BYTE},   :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::I16},    :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::I32},    :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::I64},    :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::DOUBLE}, :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::STRING}, :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::STRUCT}, :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::LIST},   :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::SET},    :foo, false) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(nil, {:type => Thrift::Types::MAP},    :foo, false) }.should raise_error(Thrift::TypeError)
     end
 
     it "should check element types on containers" do
-      field = {:type => Types::LIST, :element => {:type => Types::I32}}
-      lambda { Thrift.check_type([1, 2], field, :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type([1, nil, 2], field, :foo) }.should raise_error(TypeError)
-      field = {:type => Types::MAP, :key => {:type => Types::I32}, :value => {:type => Types::STRING}}
-      lambda { Thrift.check_type({1 => "one", 2 => "two"}, field, :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type({1 => "one", nil => "nil"}, field, :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type({1 => nil, 2 => "two"}, field, :foo) }.should raise_error(TypeError)
-      field = {:type => Types::SET, :element => {:type => Types::I32}}
-      lambda { Thrift.check_type(Set.new([1, 2]), field, :foo) }.should_not raise_error(TypeError)
-      lambda { Thrift.check_type(Set.new([1, nil, 2]), field, :foo) }.should raise_error(TypeError)
-      lambda { Thrift.check_type(Set.new([1, 2.3, 2]), field, :foo) }.should raise_error(TypeError)
-      
-      field = {:type => Types::STRUCT, :class => SpecNamespace::Hello}
-      lambda { Thrift.check_type(SpecNamespace::BoolStruct, field, :foo) }.should raise_error(TypeError)
+      field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::I32}}
+      lambda { Thrift.check_type([1, 2], field, :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type([1, nil, 2], field, :foo) }.should raise_error(Thrift::TypeError)
+      field = {:type => Thrift::Types::MAP, :key => {:type => Thrift::Types::I32}, :value => {:type => Thrift::Types::STRING}}
+      lambda { Thrift.check_type({1 => "one", 2 => "two"}, field, :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type({1 => "one", nil => "nil"}, field, :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type({1 => nil, 2 => "two"}, field, :foo) }.should raise_error(Thrift::TypeError)
+      field = {:type => Thrift::Types::SET, :element => {:type => Thrift::Types::I32}}
+      lambda { Thrift.check_type(Set.new([1, 2]), field, :foo) }.should_not raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(Set.new([1, nil, 2]), field, :foo) }.should raise_error(Thrift::TypeError)
+      lambda { Thrift.check_type(Set.new([1, 2.3, 2]), field, :foo) }.should raise_error(Thrift::TypeError)
+
+      field = {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}
+      lambda { Thrift.check_type(SpecNamespace::BoolStruct, field, :foo) }.should raise_error(Thrift::TypeError)
     end
 
-    it "should give the TypeError a readable message" do
+    it "should give the Thrift::TypeError a readable message" do
       msg = "Expected Types::STRING, received Fixnum for field foo"
-      lambda { Thrift.check_type(3, {:type => Types::STRING}, :foo) }.should raise_error(TypeError, msg)
+      lambda { Thrift.check_type(3, {:type => Thrift::Types::STRING}, :foo) }.should raise_error(Thrift::TypeError, msg)
       msg = "Expected Types::STRING, received Fixnum for field foo.element"
-      field = {:type => Types::LIST, :element => {:type => Types::STRING}}
-      lambda { Thrift.check_type([3], field, :foo) }.should raise_error(TypeError, msg)
+      field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::STRING}}
+      lambda { Thrift.check_type([3], field, :foo) }.should raise_error(Thrift::TypeError, msg)
       msg = "Expected Types::I32, received NilClass for field foo.element.key"
-      field = {:type => Types::LIST,
-               :element => {:type => Types::MAP,
-                            :key => {:type => Types::I32},
-                            :value => {:type => Types::I32}}}
-      lambda { Thrift.check_type([{nil => 3}], field, :foo) }.should raise_error(TypeError, msg)
+      field = {:type => Thrift::Types::LIST,
+               :element => {:type => Thrift::Types::MAP,
+                            :key => {:type => Thrift::Types::I32},
+                            :value => {:type => Thrift::Types::I32}}}
+      lambda { Thrift.check_type([{nil => 3}], field, :foo) }.should raise_error(Thrift::TypeError, msg)
       msg = "Expected Types::I32, received NilClass for field foo.element.value"
-      lambda { Thrift.check_type([{1 => nil}], field, :foo) }.should raise_error(TypeError, msg)
+      lambda { Thrift.check_type([{1 => nil}], field, :foo) }.should raise_error(Thrift::TypeError, msg)
     end
   end
 end

data/spec/union_spec.rb

@@ -17,21 +17,19 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftUnionSpec < Spec::ExampleGroup
-  include Thrift
-  include SpecNamespace
+describe 'Union' do
 
-  describe Union do
+  describe Thrift::Union do
     it "should return nil value in unset union" do
-      union = My_union.new
+      union = SpecNamespace::My_union.new
       union.get_set_field.should == nil
       union.get_value.should == nil
     end
 
     it "should set a field and be accessible through get_value and the named field accessor" do
-      union = My_union.new
+      union = SpecNamespace::My_union.new
       union.integer32 = 25
       union.get_set_field.should == :integer32
       union.get_value.should == 25
@@ -39,30 +37,30 @@ class ThriftUnionSpec < Spec::ExampleGroup
     end
 
     it "should work correctly when instantiated with static field constructors" do
-      union = My_union.integer32(5)
+      union = SpecNamespace::My_union.integer32(5)
       union.get_set_field.should == :integer32
       union.integer32.should == 5
     end
 
     it "should raise for wrong set field" do
-      union = My_union.new
+      union = SpecNamespace::My_union.new
       union.integer32 = 25
       lambda { union.some_characters }.should raise_error(RuntimeError, "some_characters is not union's set field.")
     end
-     
+
     it "should not be equal to nil" do
-      union = My_union.new
+      union = SpecNamespace::My_union.new
       union.should_not == nil
     end
-     
+
     it "should not equate two different unions, i32 vs. string" do
-      union = My_union.new(:integer32, 25)
-      other_union = My_union.new(:some_characters, "blah!")
+      union = SpecNamespace::My_union.new(:integer32, 25)
+      other_union = SpecNamespace::My_union.new(:some_characters, "blah!")
       union.should_not == other_union
     end
 
     it "should properly reset setfield and setvalue" do
-      union = My_union.new(:integer32, 25)
+      union = SpecNamespace::My_union.new(:integer32, 25)
       union.get_set_field.should == :integer32
       union.some_characters = "blah!"
       union.get_set_field.should == :some_characters
@@ -71,24 +69,24 @@ class ThriftUnionSpec < Spec::ExampleGroup
     end
 
     it "should not equate two different unions with different values" do
-      union = My_union.new(:integer32, 25)
-      other_union = My_union.new(:integer32, 400)
+      union = SpecNamespace::My_union.new(:integer32, 25)
+      other_union = SpecNamespace::My_union.new(:integer32, 400)
       union.should_not == other_union
     end
 
     it "should not equate two different unions with different fields" do
-      union = My_union.new(:integer32, 25)
-      other_union = My_union.new(:other_i32, 25)
+      union = SpecNamespace::My_union.new(:integer32, 25)
+      other_union = SpecNamespace::My_union.new(:other_i32, 25)
       union.should_not == other_union
     end
 
     it "should inspect properly" do
-      union = My_union.new(:integer32, 25)
+      union = SpecNamespace::My_union.new(:integer32, 25)
       union.inspect.should == "<SpecNamespace::My_union integer32: 25>"
     end
 
     it "should not allow setting with instance_variable_set" do
-      union = My_union.new(:integer32, 27)
+      union = SpecNamespace::My_union.new(:integer32, 27)
       union.instance_variable_set(:@some_characters, "hallo!")
       union.get_set_field.should == :integer32
       union.get_value.should == 27
@@ -99,42 +97,42 @@ class ThriftUnionSpec < Spec::ExampleGroup
       trans = Thrift::MemoryBufferTransport.new
       proto = Thrift::BinaryProtocol.new(trans)
 
-      union = My_union.new(:integer32, 25)
+      union = SpecNamespace::My_union.new(:integer32, 25)
       union.write(proto)
 
-      other_union = My_union.new(:integer32, 25)
+      other_union = SpecNamespace::My_union.new(:integer32, 25)
       other_union.read(proto)
       other_union.should == union
     end
 
     it "should raise when validating unset union" do
-      union = My_union.new
+      union = SpecNamespace::My_union.new
       lambda { union.validate }.should raise_error(StandardError, "Union fields are not set.")
 
-      other_union = My_union.new(:integer32, 1)
+      other_union = SpecNamespace::My_union.new(:integer32, 1)
       lambda { other_union.validate }.should_not raise_error(StandardError, "Union fields are not set.")
     end
 
     it "should validate an enum field properly" do
-      union = TestUnion.new(:enum_field, 3)
+      union = SpecNamespace::TestUnion.new(:enum_field, 3)
       union.get_set_field.should == :enum_field
-      lambda { union.validate }.should raise_error(ProtocolException, "Invalid value of field enum_field!")
+      lambda { union.validate }.should raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!")
 
-      other_union = TestUnion.new(:enum_field, 1)
-      lambda { other_union.validate }.should_not raise_error(ProtocolException, "Invalid value of field enum_field!")
+      other_union = SpecNamespace::TestUnion.new(:enum_field, 1)
+      lambda { other_union.validate }.should_not raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!")
     end
 
     it "should properly serialize and match structs with a union" do
-      union = My_union.new(:integer32, 26)
-      swu = Struct_with_union.new(:fun_union => union)
+      union = SpecNamespace::My_union.new(:integer32, 26)
+      swu = SpecNamespace::Struct_with_union.new(:fun_union => union)
 
       trans = Thrift::MemoryBufferTransport.new
       proto = Thrift::CompactProtocol.new(trans)
 
       swu.write(proto)
 
-      other_union = My_union.new(:some_characters, "hello there")
-      swu2 = Struct_with_union.new(:fun_union => other_union)
+      other_union = SpecNamespace::My_union.new(:some_characters, "hello there")
+      swu2 = SpecNamespace::Struct_with_union.new(:fun_union => other_union)
 
       swu2.should_not == swu
 
@@ -143,30 +141,30 @@ class ThriftUnionSpec < Spec::ExampleGroup
     end
 
     it "should support old style constructor" do
-      union = My_union.new(:integer32 => 26)
+      union = SpecNamespace::My_union.new(:integer32 => 26)
       union.get_set_field.should == :integer32
       union.get_value.should == 26
     end
 
     it "should not throw an error when inspected and unset" do
-      lambda{TestUnion.new().inspect}.should_not raise_error
+      lambda{SpecNamespace::TestUnion.new().inspect}.should_not raise_error
     end
 
     it "should print enum value name when inspected" do
-      My_union.new(:some_enum => SomeEnum::ONE).inspect.should == "<SpecNamespace::My_union some_enum: ONE (0)>"
+      SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect.should == "<SpecNamespace::My_union some_enum: ONE (0)>"
 
-      My_union.new(:my_map => {SomeEnum::ONE => [SomeEnum::TWO]}).inspect.should == "<SpecNamespace::My_union my_map: {ONE (0): [TWO (1)]}>" 
+      SpecNamespace::My_union.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect.should == "<SpecNamespace::My_union my_map: {ONE (0): [TWO (1)]}>"
     end
 
     it "should offer field? methods" do
-      My_union.new.some_enum?.should be_false
-      My_union.new(:some_enum => SomeEnum::ONE).some_enum?.should be_true
-      My_union.new(:im_true => false).im_true?.should be_true
-      My_union.new(:im_true => true).im_true?.should be_true
+      SpecNamespace::My_union.new.some_enum?.should be_false
+      SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).some_enum?.should be_true
+      SpecNamespace::My_union.new(:im_true => false).im_true?.should be_true
+      SpecNamespace::My_union.new(:im_true => true).im_true?.should be_true
     end
 
     it "should pretty print binary fields" do
-      TestUnion.new(:binary_field => "\001\002\003").inspect.should == "<SpecNamespace::TestUnion binary_field: 010203>"
+      SpecNamespace::TestUnion.new(:binary_field => "\001\002\003").inspect.should == "<SpecNamespace::TestUnion binary_field: 010203>"
     end
 
     it "should be comparable" do
@@ -177,10 +175,10 @@ class ThriftUnionSpec < Spec::ExampleGroup
         [1,   1,  1,  0]]
 
       objs = [
-        TestUnion.new(:string_field, "blah"), 
-        TestUnion.new(:string_field, "blahblah"),
-        TestUnion.new(:i32_field, 1),
-        TestUnion.new()]
+        SpecNamespace::TestUnion.new(:string_field, "blah"),
+        SpecNamespace::TestUnion.new(:string_field, "blahblah"),
+        SpecNamespace::TestUnion.new(:i32_field, 1),
+        SpecNamespace::TestUnion.new()]
 
       for y in 0..3
         for x in 0..3

data/spec/unix_socket_spec.rb

@@ -17,16 +17,15 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
-class ThriftUNIXSocketSpec < Spec::ExampleGroup
-  include Thrift
+describe 'UNIXSocket' do
 
-  describe UNIXSocket do
+  describe Thrift::UNIXSocket do
     before(:each) do
       @path = '/tmp/thrift_spec_socket'
-      @socket = UNIXSocket.new(@path)
+      @socket = Thrift::UNIXSocket.new(@path)
       @handle = mock("Handle", :closed? => false)
       @handle.stub!(:close)
       ::UNIXSocket.stub!(:new).and_return(@handle)
@@ -41,14 +40,14 @@ class ThriftUNIXSocketSpec < Spec::ExampleGroup
 
     it "should accept an optional timeout" do
       ::UNIXSocket.stub!(:new)
-      UNIXSocket.new(@path, 5).timeout.should == 5
+      Thrift::UNIXSocket.new(@path, 5).timeout.should == 5
     end
   end
 
-  describe UNIXServerSocket do
+  describe Thrift::UNIXServerSocket do
     before(:each) do
       @path = '/tmp/thrift_spec_socket'
-      @socket = UNIXServerSocket.new(@path)
+      @socket = Thrift::UNIXServerSocket.new(@path)
     end
 
     it "should create a handle when calling listen" do
@@ -63,7 +62,7 @@ class ThriftUNIXSocketSpec < Spec::ExampleGroup
       sock = mock("sock")
       handle.should_receive(:accept).and_return(sock)
       trans = mock("UNIXSocket")
-      UNIXSocket.should_receive(:new).and_return(trans)
+      Thrift::UNIXSocket.should_receive(:new).and_return(trans)
       trans.should_receive(:handle=).with(sock)
       @socket.accept.should == trans
     end

data/test/debug_proto/gen-rb/debug_proto_test_constants.rb

@@ -1,12 +1,13 @@
 #
-# Autogenerated by Thrift Compiler (0.8.0)
+# Autogenerated by Thrift Compiler (0.9.0)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
 
+require 'thrift'
 require 'debug_proto_test_types'
 
-COMPACT_TEST = CompactProtoTestStruct.new({
+COMPACT_TEST = ::CompactProtoTestStruct.new({
   %q"a_byte" => 127,
   %q"a_i16" => 32000,
   %q"a_i32" => 1000000000,
@@ -15,7 +16,7 @@ COMPACT_TEST = CompactProtoTestStruct.new({
   %q"a_string" => %q"my string",
   %q"true_field" => true,
   %q"false_field" => false,
-  %q"empty_struct_field" => Empty.new({
+  %q"empty_struct_field" => ::Empty.new({
   }),
   %q"byte_list" => [
     -127,
@@ -69,9 +70,9 @@ COMPACT_TEST = CompactProtoTestStruct.new({
     false,
   ],
   %q"struct_list" => [
-    Empty.new({
+    ::Empty.new({
     }),
-    Empty.new({
+    ::Empty.new({
     }),
   ],
   %q"byte_set" => Set.new([
@@ -119,7 +120,7 @@ COMPACT_TEST = CompactProtoTestStruct.new({
     false,
   ]),
   %q"struct_set" => Set.new([
-    Empty.new({
+    ::Empty.new({
     }),
   ]),
   %q"byte_byte_map" => {
@@ -266,7 +267,7 @@ MY_ENUM_MAP = {
 }
 
 EXTRA_CRAZY_MAP = {
-    1 => StructWithSomeEnum.new({
+    1 => ::StructWithSomeEnum.new({
     %q"blah" =>     2,
   }),
 }