thrift 0.0.751142

data/spec/socket_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + "/socket_spec_shared"
+
+class ThriftSocketSpec < Spec::ExampleGroup
+  include Thrift
+
+  describe Socket do
+    before(:each) do
+      @socket = Socket.new
+      @handle = mock("Handle", :closed? => false)
+      @handle.stub!(:close)
+      @handle.stub!(:connect_nonblock)
+      ::Socket.stub!(:new).and_return(@handle)
+    end
+
+    it_should_behave_like "a socket"
+
+    it "should raise a TransportException when it cannot open a socket" do
+      ::Socket.should_receive(:new).and_raise(StandardError)
+      lambda { @socket.open }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+    end
+
+    it "should open a ::Socket with default args" do
+      ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true))
+      ::Socket.should_receive(:getaddrinfo).with("localhost", 9090).and_return([[]])
+      ::Socket.should_receive(:sockaddr_in)
+      @socket.open
+    end
+
+    it "should accept host/port options" do
+      ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true))
+      ::Socket.should_receive(:getaddrinfo).with("my.domain", 1234).and_return([[]])
+      ::Socket.should_receive(:sockaddr_in)
+      Socket.new('my.domain', 1234).open
+    end
+
+    it "should accept an optional timeout" do
+      ::Socket.stub!(:new)
+      Socket.new('localhost', 8080, 5).timeout.should == 5
+    end
+  end
+
+  describe ServerSocket do
+    before(:each) do
+      @socket = ServerSocket.new(1234)
+    end
+
+    it "should create a handle when calling listen" do
+      TCPServer.should_receive(:new).with(nil, 1234)
+      @socket.listen
+    end
+
+    it "should accept an optional host argument" do
+      @socket = ServerSocket.new('localhost', 1234)
+      TCPServer.should_receive(:new).with('localhost', 1234)
+      @socket.listen
+    end
+
+    it "should create a Thrift::Socket to wrap accepted sockets" do
+      handle = mock("TCPServer")
+      TCPServer.should_receive(:new).with(nil, 1234).and_return(handle)
+      @socket.listen
+      sock = mock("sock")
+      handle.should_receive(:accept).and_return(sock)
+      trans = mock("Socket")
+      Socket.should_receive(:new).and_return(trans)
+      trans.should_receive(:handle=).with(sock)
+      @socket.accept.should == trans
+    end
+
+    it "should close the handle when closed" do
+      handle = mock("TCPServer", :closed? => false)
+      TCPServer.should_receive(:new).with(nil, 1234).and_return(handle)
+      @socket.listen
+      handle.should_receive(:close)
+      @socket.close
+    end
+
+    it "should return nil when accepting if there is no handle" do
+      @socket.accept.should be_nil
+    end
+
+    it "should return true for closed? when appropriate" do
+      handle = mock("TCPServer", :closed? => false)
+      TCPServer.stub!(:new).and_return(handle)
+      @socket.listen
+      @socket.should_not be_closed
+      handle.stub!(:close)
+      @socket.close
+      @socket.should be_closed
+      @socket.listen
+      @socket.should_not be_closed
+      handle.stub!(:closed?).and_return(true)
+      @socket.should be_closed
+    end
+  end
+end

data/spec/socket_spec_shared.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+shared_examples_for "a socket" do
+  it "should open a socket" do
+    @socket.open.should == @handle
+  end
+
+  it "should be open whenever it has a handle" do
+    @socket.should_not be_open
+    @socket.open
+    @socket.should be_open
+    @socket.handle = nil
+    @socket.should_not be_open
+    @socket.handle = @handle
+    @socket.close
+    @socket.should_not be_open
+  end
+
+  it "should write data to the handle" do
+    @socket.open
+    @handle.should_receive(:write).with("foobar")
+    @socket.write("foobar")
+    @handle.should_receive(:write).with("fail").and_raise(StandardError)
+    lambda { @socket.write("fail") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+  end
+
+  it "should raise an error when it cannot read from the handle" do
+    @socket.open
+    @handle.should_receive(:readpartial).with(17).and_raise(StandardError)
+    lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+  end
+
+  it "should return the data read when reading from the handle works" do
+    @socket.open
+    @handle.should_receive(:readpartial).with(17).and_return("test data")
+    @socket.read(17).should == "test data"
+  end
+
+  it "should declare itself as closed when it has an error" do
+    @socket.open
+    @handle.should_receive(:write).with("fail").and_raise(StandardError)
+    @socket.should be_open
+    lambda { @socket.write("fail") }.should raise_error
+    @socket.should_not be_open
+  end
+
+  it "should raise an error when the stream is closed" do
+    @socket.open
+    @handle.stub!(:closed?).and_return(true)
+    @socket.should_not be_open
+    lambda { @socket.write("fail") }.should raise_error(IOError, "closed stream")
+    lambda { @socket.read(10) }.should raise_error(IOError, "closed stream")
+  end
+
+  it "should support the timeout accessor for read" do
+    @socket.timeout = 3
+    @socket.open
+    IO.should_receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
+    @handle.should_receive(:readpartial).with(17).and_return("test data")
+    @socket.read(17).should == "test data"
+  end
+
+  it "should support the timeout accessor for write" do
+    @socket.timeout = 3
+    @socket.open
+    IO.should_receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
+    @handle.should_receive(:write_nonblock).with("test data").and_return(4)
+    @handle.should_receive(:write_nonblock).with(" data").and_return(5)
+    @socket.write("test data").should == 9
+  end
+
+  it "should raise an error when read times out" do
+    @socket.timeout = 0.5
+    @socket.open
+    IO.should_receive(:select).with([@handle], nil, nil, 0.5).at_least(1).times.and_return(nil)
+    lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
+  end
+
+  it "should raise an error when write times out" do
+    @socket.timeout = 0.5
+    @socket.open
+    IO.should_receive(:select).with(nil, [@handle], nil, 0.5).any_number_of_times.and_return(nil)
+    lambda { @socket.write("test data") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+# require at least 1.1.4 to fix a bug with describing Modules
+gem 'rspec', '>= 1.1.4'
+require 'spec'
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
+
+# pretend we already loaded fastthread, otherwise the nonblockingserver_spec
+# will get screwed up
+# $" << 'fastthread.bundle'
+
+# turn on deprecation so we can test it
+module Thrift
+  # squelch any warnings if we happen to get required twice
+  remove_const(:DEPRECATION) if const_defined? :DEPRECATION
+  DEPRECATION = true
+end
+
+require File.dirname(__FILE__) + '/../lib/thrift'
+
+class Object
+  # tee is a useful method, so let's let our tests have it
+  def tee(&block)
+    block.call(self)
+    self
+  end
+end
+
+Spec::Runner.configure do |configuration|
+  configuration.before(:each) do
+    Thrift.type_checking = true
+  end
+end
+
+require "thrift_native"

data/spec/struct_spec.rb

@@ -0,0 +1,244 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/gen-rb/ThriftSpec_types'
+
+# require "binaryprotocolaccelerated"
+
+class ThriftStructSpec < Spec::ExampleGroup
+  include Thrift
+  include SpecNamespace
+
+  describe Struct do
+    it "should iterate over all fields properly" do
+      fields = {}
+      Foo.new.each_field { |fid,type,name,default,optional| fields[fid] = [type,name,default,optional] }
+      fields.should == {
+        1 => [Types::I32, 'simple', 53, nil],
+        2 => [Types::STRING, 'words', "words", nil],
+        3 => [Types::STRUCT, 'hello', Hello.new(:greeting => 'hello, world!'), nil],
+        4 => [Types::LIST, 'ints', [1, 2, 2, 3], nil],
+        5 => [Types::MAP, 'complex', nil, nil],
+        6 => [Types::SET, 'shorts', Set.new([5, 17, 239]), nil],
+        7 => [Types::STRING, 'opt_string', nil, true]
+      }
+    end
+
+    it "should initialize all fields to defaults" do
+      struct = Foo.new
+      struct.simple.should == 53
+      struct.words.should == "words"
+      struct.hello.should == Hello.new(:greeting => 'hello, world!')
+      struct.ints.should == [1, 2, 2, 3]
+      struct.complex.should be_nil
+      struct.shorts.should == Set.new([5, 17, 239])
+    end
+
+    it "should not share default values between instances" do
+      begin
+        struct = Foo.new
+        struct.ints << 17
+        Foo.new.ints.should == [1,2,2,3]
+      ensure
+        # ensure no leakage to other tests
+        Foo::FIELDS[4][:default] = [1,2,2,3]
+      end
+    end
+
+    it "should properly initialize boolean values" do
+      struct = BoolStruct.new(:yesno => false)
+      struct.yesno.should be_false
+    end
+
+    it "should have proper == semantics" do
+      Foo.new.should_not == Hello.new
+      Foo.new.should == Foo.new
+      Foo.new(:simple => 52).should_not == Foo.new
+    end
+
+    it "should read itself off the wire" do
+      struct = Foo.new
+      prot = Protocol.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(
+        ['complex', Types::MAP, 5], # Foo
+        ['words', Types::STRING, 2], # Foo
+        ['hello', Types::STRUCT, 3], # Foo
+          ['greeting', Types::STRING, 1], # Hello
+          [nil, Types::STOP, 0], # Hello
+        ['simple', Types::I32, 1], # Foo
+        ['ints', Types::LIST, 4], # Foo
+        ['shorts', Types::SET, 6], # Foo
+        [nil, Types::STOP, 0] # Hello
+      )
+      prot.should_receive(:read_field_end).exactly(7).times
+      prot.should_receive(:read_map_begin).and_return(
+        [Types::I32, Types::MAP, 2], # complex
+          [Types::STRING, Types::DOUBLE, 2], # complex/1/value
+          [Types::STRING, Types::DOUBLE, 1] # complex/2/value
+      )
+      prot.should_receive(:read_map_end).exactly(3).times
+      prot.should_receive(:read_list_begin).and_return([Types::I32, 4])
+      prot.should_receive(:read_list_end)
+      prot.should_receive(:read_set_begin).and_return([Types::I16, 2])
+      prot.should_receive(:read_set_end)
+      prot.should_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)
+      struct.read(prot)
+
+      struct.simple.should == 42
+      struct.complex.should == {1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}}
+      struct.hello.should == 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])
+    end
+
+    it "should skip unexpected fields in structs and use default values" do
+      struct = Foo.new
+      prot = Protocol.new(mock("transport"))
+      prot.should_receive(:read_struct_begin)
+      prot.should_receive(:read_struct_end)
+      prot.should_receive(:read_field_begin).and_return(
+        ['simple', Types::I32, 1],
+        ['complex', Types::STRUCT, 5],
+        ['thinz', Types::MAP, 7],
+        ['foobar', Types::I32, 3],
+        ['words', Types::STRING, 2],
+        [nil, 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(Types::STRUCT)
+      prot.should_receive(:skip).with(Types::MAP)
+      # prot.should_receive(:read_map_begin).and_return([Types::I32, Types::I32, 0])
+      # prot.should_receive(:read_map_end)
+      prot.should_receive(:skip).with(Types::I32)
+      struct.read(prot)
+
+      struct.simple.should == 42
+      struct.complex.should be_nil
+      struct.words.should == "foobar"
+      struct.hello.should == Hello.new(:greeting => 'hello, world!')
+      struct.ints.should == [1, 2, 2, 3]
+      struct.shorts.should == Set.new([5, 17, 239])
+    end
+
+    it "should write itself to the wire" do
+      prot = Protocol.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', 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', 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', 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', Types::I32, 1)
+      prot.should_receive(:write_i32).with(53)
+      prot.should_receive(:write_field_begin).with('hello', Types::STRUCT, 3)
+      prot.should_receive(:write_field_begin).with('greeting', Types::STRING, 1)
+      prot.should_receive(:write_string).with('hello, world!')
+      prot.should_receive(:write_map_begin).with(Types::I32, Types::MAP, 1)
+      prot.should_receive(:write_map_begin).with(Types::STRING, Types::DOUBLE, 1)
+      prot.should_receive(:write_map_end).twice
+      prot.should_receive(:write_list_begin).with(Types::I32, 4)
+      prot.should_receive(:write_list_end)
+      prot.should_receive(:write_set_begin).with(Types::I16, 3)
+      prot.should_receive(:write_set_end)
+
+      struct = Foo.new
+      struct.words = nil
+      struct.complex = {5 => {"foo" => 1.23}}
+      struct.write(prot)
+    end
+
+    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 = Foo.new
+      lambda { struct.send :write_container, nil, nil, {:type => "foo"} }.should 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 { Hello.new(:greeting => 3) }.should raise_error(TypeError, "Expected Types::STRING, received Fixnum for field greeting")
+      ensure
+        Thrift.type_checking = false
+      end
+      lambda { Hello.new(:greeting => 3) }.should_not raise_error(TypeError)
+    end
+
+    it "should support optional type-checking in field accessors" do
+      Thrift.type_checking = true
+      begin
+        hello = Hello.new
+        lambda { hello.greeting = 3 }.should raise_error(TypeError, "Expected Types::STRING, received Fixnum for field greeting")
+      ensure
+        Thrift.type_checking = false
+      end
+      lambda { hello.greeting = 3 }.should_not raise_error(TypeError)
+    end
+
+    it "should raise an exception when unknown types are given to Thrift::Struct.new" do
+      lambda { Hello.new(:fish => 'salmon') }.should raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
+    end
+
+    it "should support `raise Xception, 'message'` for Exception structs" do
+      begin
+        raise Xception, "something happened"
+      rescue Thrift::Exception => e
+        e.message.should == "something happened"
+        e.code.should == 1
+        # ensure it gets serialized properly, this is the really important part
+        prot = Protocol.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', Types::STRING, 1)#, "something happened")
+        prot.should_receive(:write_string).with("something happened")
+        prot.should_receive(:write_field_begin).with('code', Types::I32, 2)#, 1)
+        prot.should_receive(:write_i32).with(1)
+        prot.should_receive(:write_field_stop)
+        prot.should_receive(:write_field_end).twice
+
+        e.write(prot)
+      end
+    end
+
+    it "should support the regular initializer for exception structs" do
+      begin
+        raise Xception, :message => "something happened", :code => 5
+      rescue Thrift::Exception => e
+        e.message.should == "something happened"
+        e.code.should == 5
+        prot = Protocol.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', Types::STRING, 1)
+        prot.should_receive(:write_string).with("something happened")
+        prot.should_receive(:write_field_begin).with('code', Types::I32, 2)
+        prot.should_receive(:write_i32).with(5)
+        prot.should_receive(:write_field_stop)
+        prot.should_receive(:write_field_end).twice
+
+        e.write(prot)
+      end
+    end
+  end
+end