poolparty 1.3.15 → 1.4.0

data/vendor/gems/thrift/spec/serializer_spec.rb

@@ -1,69 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-require File.dirname(__FILE__) + '/spec_helper'
-
-class ThriftSerializerSpec < Spec::ExampleGroup
-  include Thrift
-  include SpecNamespace
-
-  describe Serializer do
-    it "should serialize structs to binary by default" do
-      serializer = Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)
-      data = serializer.serialize(Hello.new(:greeting => "'Ello guv'nor!"))
-      data.should == "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
-    end
-
-    it "should serialize structs to the given protocol" do
-      protocol = BaseProtocol.new(mock("transport"))
-      protocol.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
-      protocol.should_receive(:write_field_begin).with("greeting", Types::STRING, 1)
-      protocol.should_receive(:write_string).with("Good day")
-      protocol.should_receive(:write_field_end)
-      protocol.should_receive(:write_field_stop)
-      protocol.should_receive(:write_struct_end)
-      protocol_factory = mock("ProtocolFactory")
-      protocol_factory.stub!(:get_protocol).and_return(protocol)
-      serializer = Serializer.new(protocol_factory)
-      serializer.serialize(Hello.new(:greeting => "Good day"))
-    end
-  end
-
-  describe Deserializer do
-    it "should deserialize structs from binary by default" do
-      deserializer = Deserializer.new
-      data = "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
-      deserializer.deserialize(Hello.new, data).should == Hello.new(:greeting => "'Ello guv'nor!")
-    end
-
-    it "should deserialize structs from the given protocol" do
-      protocol = BaseProtocol.new(mock("transport"))
-      protocol.should_receive(:read_struct_begin).and_return("SpecNamespace::Hello")
-      protocol.should_receive(:read_field_begin).and_return(["greeting", Types::STRING, 1],
-                                                            [nil, Types::STOP, 0])
-      protocol.should_receive(:read_string).and_return("Good day")
-      protocol.should_receive(:read_field_end)
-      protocol.should_receive(:read_struct_end)
-      protocol_factory = mock("ProtocolFactory")
-      protocol_factory.stub!(:get_protocol).and_return(protocol)
-      deserializer = Deserializer.new(protocol_factory)
-      deserializer.deserialize(Hello.new, "").should == Hello.new(:greeting => "Good day")
-    end
-  end
-end

data/vendor/gems/thrift/spec/server_socket_spec.rb

@@ -1,80 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + "/socket_spec_shared"
-
-class ThriftServerSocketSpec < Spec::ExampleGroup
-  include Thrift
-
-  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/vendor/gems/thrift/spec/server_spec.rb

@@ -1,160 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-require File.dirname(__FILE__) + '/spec_helper'
-
-class ThriftServerSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe BaseServer do
-    it "should default to BaseTransportFactory and BinaryProtocolFactory when not specified" do
-      server = BaseServer.new(mock("Processor"), mock("BaseServerTransport"))
-      server.instance_variable_get(:'@transport_factory').should be_an_instance_of(BaseTransportFactory)
-      server.instance_variable_get(:'@protocol_factory').should be_an_instance_of(BinaryProtocolFactory)
-    end
-
-    # serve is a noop, so can't test that
-  end
-
-  shared_examples_for "servers" do
-    before(:each) do
-      @processor = mock("Processor")
-      @serverTrans = mock("ServerTransport")
-      @trans = mock("BaseTransport")
-      @prot = mock("BaseProtocol")
-      @client = mock("Client")
-      @server = server_type.new(@processor, @serverTrans, @trans, @prot)
-    end
-  end
-
-  describe SimpleServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      SimpleServer
-    end
-
-    it "should serve in the main thread" do
-      @serverTrans.should_receive(:listen).ordered
-      @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
-      @trans.should_receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      @prot.should_receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      x = 0
-      @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then throw :stop
-        end
-      end
-      @trans.should_receive(:close).exactly(3).times
-      @serverTrans.should_receive(:close).ordered
-      lambda { @server.serve }.should throw_symbol(:stop)
-    end
-  end
-
-  describe ThreadedServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      ThreadedServer
-    end
-
-    it "should serve using threads" do
-      @serverTrans.should_receive(:listen).ordered
-      @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
-      @trans.should_receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      @prot.should_receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      Thread.should_receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
-      x = 0
-      @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then throw :stop
-        end
-      end
-      @trans.should_receive(:close).exactly(3).times
-      @serverTrans.should_receive(:close).ordered
-      lambda { @server.serve }.should throw_symbol(:stop)
-    end
-  end
-
-  describe ThreadPoolServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      # put this stuff here so it runs before the server is created
-      @threadQ = mock("SizedQueue")
-      SizedQueue.should_receive(:new).with(20).and_return(@threadQ)
-      @excQ = mock("Queue")
-      Queue.should_receive(:new).and_return(@excQ)
-      ThreadPoolServer
-    end
-
-    it "should set up the queues" do
-      @server.instance_variable_get(:'@thread_q').should be(@threadQ)
-      @server.instance_variable_get(:'@exception_q').should be(@excQ)
-    end
-
-    it "should serve inside a thread" do
-      Thread.should_receive(:new).and_return do |block|
-        @server.should_receive(:serve)
-        block.call
-        @server.rspec_verify
-      end
-      @excQ.should_receive(:pop).and_throw(:popped)
-      lambda { @server.rescuable_serve }.should throw_symbol(:popped)
-    end
-
-    it "should avoid running the server twice when retrying rescuable_serve" do
-      Thread.should_receive(:new).and_return do |block|
-        @server.should_receive(:serve)
-        block.call
-        @server.rspec_verify
-      end
-      @excQ.should_receive(:pop).twice.and_throw(:popped)
-      lambda { @server.rescuable_serve }.should throw_symbol(:popped)
-      lambda { @server.rescuable_serve }.should throw_symbol(:popped)
-    end
-
-    it "should serve using a thread pool" do
-      @serverTrans.should_receive(:listen).ordered
-      @threadQ.should_receive(:push).with(:token)
-      @threadQ.should_receive(:pop)
-      Thread.should_receive(:new).and_yield
-      @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
-      @trans.should_receive(:get_transport).exactly(3).times.and_return(@trans)
-      @prot.should_receive(:get_protocol).exactly(3).times.and_return(@prot)
-      x = 0
-      error = RuntimeError.new("Stopped")
-      @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then raise error
-        end
-      end
-      @trans.should_receive(:close).exactly(3).times
-      @excQ.should_receive(:push).with(error).and_throw(:stop)
-      @serverTrans.should_receive(:close)
-      lambda { @server.serve }.should throw_symbol(:stop)
-    end
-  end
-end

data/vendor/gems/thrift/spec/socket_spec.rb

@@ -1,61 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-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
-end

data/vendor/gems/thrift/spec/socket_spec_shared.rb

@@ -1,104 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-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/vendor/gems/thrift/spec/spec_helper.rb

@@ -1,60 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-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 nonblocking_server_spec
-# will get screwed up
-# $" << 'fastthread.bundle'
-
-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
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. debug_proto_test gen-rb])
-require "srv"
-require "debug_proto_test_constants"
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb])
-require 'thrift_spec_types'
-require 'nonblocking_service'
-
-module Fixtures
-  COMPACT_PROTOCOL_TEST_STRUCT = COMPACT_TEST.dup
-  COMPACT_PROTOCOL_TEST_STRUCT.a_binary = [0,1,2,3,4,5,6,7,8].pack('c*')
-  COMPACT_PROTOCOL_TEST_STRUCT.set_byte_map = nil
-  COMPACT_PROTOCOL_TEST_STRUCT.map_byte_map = nil
-end