poolparty 1.3.15 → 1.4.0

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

@@ -1,142 +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 ThriftExceptionSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe Exception do
-    it "should have an accessible message" do
-      e = Exception.new("test message")
-      e.message.should == "test message"
-    end
-  end
-
-  describe ApplicationException do
-    it "should inherit from Thrift::Exception" do
-      ApplicationException.superclass.should == Exception
-    end
-
-    it "should have an accessible type and message" do
-      e = ApplicationException.new
-      e.type.should == ApplicationException::UNKNOWN
-      e.message.should be_nil
-      e = ApplicationException.new(ApplicationException::UNKNOWN_METHOD, "test message")
-      e.type.should == ApplicationException::UNKNOWN_METHOD
-      e.message.should == "test message"
-    end
-
-    it "should read a struct off of a protocol" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:read_struct_begin).ordered
-      prot.should_receive(:read_field_begin).exactly(3).times.and_return(
-        ["message", Types::STRING, 1],
-        ["type", Types::I32, 2],
-        [nil, Types::STOP, 0]
-      )
-      prot.should_receive(:read_string).ordered.and_return "test message"
-      prot.should_receive(:read_i32).ordered.and_return ApplicationException::BAD_SEQUENCE_ID
-      prot.should_receive(:read_field_end).exactly(2).times
-      prot.should_receive(:read_struct_end).ordered
-
-      e = ApplicationException.new
-      e.read(prot)
-      e.message.should == "test message"
-      e.type.should == ApplicationException::BAD_SEQUENCE_ID
-    end
-
-    it "should skip bad fields when reading a struct" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:read_struct_begin).ordered
-      prot.should_receive(:read_field_begin).exactly(5).times.and_return(
-        ["type", Types::I32, 2],
-        ["type", Types::STRING, 2],
-        ["message", Types::MAP, 1],
-        ["message", Types::STRING, 3],
-        [nil, Types::STOP, 0]
-      )
-      prot.should_receive(:read_i32).and_return ApplicationException::INVALID_MESSAGE_TYPE
-      prot.should_receive(:skip).with(Types::STRING).twice
-      prot.should_receive(:skip).with(Types::MAP)
-      prot.should_receive(:read_field_end).exactly(4).times
-      prot.should_receive(:read_struct_end).ordered
-
-      e = ApplicationException.new
-      e.read(prot)
-      e.message.should be_nil
-      e.type.should == ApplicationException::INVALID_MESSAGE_TYPE
-    end
-
-    it "should write a Thrift::ApplicationException struct to the oprot" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_begin).with("message", Types::STRING, 1).ordered
-      prot.should_receive(:write_string).with("test message").ordered
-      prot.should_receive(:write_field_begin).with("type", Types::I32, 2).ordered
-      prot.should_receive(:write_i32).with(ApplicationException::UNKNOWN_METHOD).ordered
-      prot.should_receive(:write_field_end).twice
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
-
-      e = ApplicationException.new(ApplicationException::UNKNOWN_METHOD, "test message")
-      e.write(prot)
-    end
-
-    it "should skip nil fields when writing to the oprot" do
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_begin).with("message", Types::STRING, 1).ordered
-      prot.should_receive(:write_string).with("test message").ordered
-      prot.should_receive(:write_field_end).ordered
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
-
-      e = ApplicationException.new(nil, "test message")
-      e.write(prot)
-
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_begin).with("type", Types::I32, 2).ordered
-      prot.should_receive(:write_i32).with(ApplicationException::BAD_SEQUENCE_ID).ordered
-      prot.should_receive(:write_field_end).ordered
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
-
-      e = ApplicationException.new(ApplicationException::BAD_SEQUENCE_ID)
-      e.write(prot)
-
-      prot = mock("MockProtocol")
-      prot.should_receive(:write_struct_begin).with("Thrift::ApplicationException").ordered
-      prot.should_receive(:write_field_stop).ordered
-      prot.should_receive(:write_struct_end).ordered
-
-      e = ApplicationException.new(nil)
-      e.write(prot)
-    end
-  end
-
-  describe ProtocolException do
-    it "should have an accessible type" do
-      prot = ProtocolException.new(ProtocolException::SIZE_LIMIT, "message")
-      prot.type.should == ProtocolException::SIZE_LIMIT
-      prot.message.should == "message"
-    end
-  end
-end

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

@@ -1,49 +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 ThriftHTTPClientTransportSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe HTTPClientTransport do
-    before(:each) do
-      @client = HTTPClientTransport.new("http://my.domain.com/path/to/service")
-    end
-
-    it "should always be open" do
-      @client.should be_open
-      @client.close
-      @client.should be_open
-    end
-
-    it "should post via HTTP and return the results" do
-      @client.write "a test"
-      @client.write " frame"
-      Net::HTTP.should_receive(:new).with("my.domain.com", 80).and_return do
-        mock("Net::HTTP").tee do |http|
-          http.should_receive(:use_ssl=).with(false)
-          http.should_receive(:post).with("/path/to/service", "a test frame", {"Content-Type"=>"application/x-thrift"}).and_return([nil, "data"])
-        end
-      end
-      @client.flush
-      @client.read(10).should == "data"
-    end
-  end
-end

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

@@ -1,117 +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 'thrift/server/mongrel_http_server'
-
-class ThriftHTTPServerSpec < Spec::ExampleGroup
-  include Thrift
-
-  Handler = MongrelHTTPServer::Handler
-
-  describe MongrelHTTPServer do
-    it "should have appropriate defaults" do
-      mock_factory = mock("BinaryProtocolFactory")
-      mock_proc = mock("Processor")
-      BinaryProtocolFactory.should_receive(:new).and_return(mock_factory)
-      Mongrel::HttpServer.should_receive(:new).with("0.0.0.0", 80).and_return do
-        mock("Mongrel::HttpServer").tee do |mock|
-          handler = mock("Handler")
-          Handler.should_receive(:new).with(mock_proc, mock_factory).and_return(handler)
-          mock.should_receive(:register).with("/", handler)
-        end
-      end
-      MongrelHTTPServer.new(mock_proc)
-    end
-
-    it "should understand :ip, :port, :path, and :protocol_factory" do
-      mock_proc = mock("Processor")
-      mock_factory = mock("ProtocolFactory")
-      Mongrel::HttpServer.should_receive(:new).with("1.2.3.4", 1234).and_return do
-        mock("Mongrel::HttpServer").tee do |mock|
-          handler = mock("Handler")
-          Handler.should_receive(:new).with(mock_proc, mock_factory).and_return(handler)
-          mock.should_receive(:register).with("/foo", handler)
-        end
-      end
-      MongrelHTTPServer.new(mock_proc, :ip => "1.2.3.4", :port => 1234, :path => "foo",
-                                             :protocol_factory => mock_factory)
-    end
-
-    it "should serve using Mongrel::HttpServer" do
-      BinaryProtocolFactory.stub!(:new)
-      Mongrel::HttpServer.should_receive(:new).and_return do
-        mock("Mongrel::HttpServer").tee do |mock|
-          Handler.stub!(:new)
-          mock.stub!(:register)
-          mock.should_receive(:run).and_return do
-            mock("Mongrel::HttpServer.run").tee do |runner|
-              runner.should_receive(:join)
-            end
-          end
-        end
-      end
-      MongrelHTTPServer.new(nil).serve
-    end
-  end
-
-  describe MongrelHTTPServer::Handler do
-    before(:each) do
-      @processor = mock("Processor")
-      @factory = mock("ProtocolFactory")
-      @handler = Handler.new(@processor, @factory)
-    end
-
-    it "should return 404 for non-POST requests" do
-      request = mock("request", :params => {"REQUEST_METHOD" => "GET"})
-      response = mock("response")
-      response.should_receive(:start).with(404)
-      response.should_not_receive(:start).with(200)
-      @handler.process(request, response)
-    end
-
-    it "should serve using application/x-thrift" do
-      request = mock("request", :params => {"REQUEST_METHOD" => "POST"}, :body => nil)
-      response = mock("response")
-      head = mock("head")
-      head.should_receive(:[]=).with("Content-Type", "application/x-thrift")
-      IOStreamTransport.stub!(:new)
-      @factory.stub!(:get_protocol)
-      @processor.stub!(:process)
-      response.should_receive(:start).with(200).and_yield(head, nil)
-      @handler.process(request, response)
-    end
-
-    it "should use the IOStreamTransport" do
-      body = mock("body")
-      request = mock("request", :params => {"REQUEST_METHOD" => "POST"}, :body => body)
-      response = mock("response")
-      head = mock("head")
-      head.stub!(:[]=)
-      out = mock("out")
-      protocol = mock("protocol")
-      transport = mock("transport")
-      IOStreamTransport.should_receive(:new).with(body, out).and_return(transport)
-      @factory.should_receive(:get_protocol).with(transport).and_return(protocol)
-      @processor.should_receive(:process).with(protocol, protocol)
-      response.should_receive(:start).with(200).and_yield(head, out)
-      @handler.process(request, response)
-    end
-  end
-end

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

@@ -1,265 +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 ThriftNonblockingServerSpec < Spec::ExampleGroup
-  include Thrift
-  include SpecNamespace
-
-  class Handler
-    def initialize
-      @queue = Queue.new
-    end
-
-    attr_accessor :server
-
-    def greeting(english)
-      if english
-        SpecNamespace::Hello.new
-      else
-        SpecNamespace::Hello.new(:greeting => "Aloha!")
-      end
-    end
-
-    def block
-      @queue.pop
-    end
-
-    def unblock(n)
-      n.times { @queue.push true }
-    end
-
-    def sleep(time)
-      Kernel.sleep time
-    end
-
-    def shutdown
-      @server.shutdown(0, false)
-    end
-  end
-
-  class SpecTransport < BaseTransport
-    def initialize(transport, queue)
-      @transport = transport
-      @queue = queue
-      @flushed = false
-    end
-
-    def open?
-      @transport.open?
-    end
-
-    def open
-      @transport.open
-    end
-
-    def close
-      @transport.close
-    end
-
-    def read(sz)
-      @transport.read(sz)
-    end
-
-    def write(buf,sz=nil)
-      @transport.write(buf, sz)
-    end
-
-    def flush
-      @queue.push :flushed unless @flushed or @queue.nil?
-      @flushed = true
-      @transport.flush
-    end
-  end
-
-  class SpecServerSocket < ServerSocket
-    def initialize(host, port, queue)
-      super(host, port)
-      @queue = queue
-    end
-
-    def listen
-      super
-      @queue.push :listen
-    end
-  end
-
-  describe Thrift::NonblockingServer do
-    before(:each) do
-      @port = 43251
-      handler = Handler.new
-      processor = NonblockingService::Processor.new(handler)
-      queue = Queue.new
-      @transport = SpecServerSocket.new('localhost', @port, queue)
-      transport_factory = FramedTransportFactory.new
-      logger = Logger.new(STDERR)
-      logger.level = Logger::WARN
-      @server = NonblockingServer.new(processor, @transport, transport_factory, nil, 5, logger)
-      handler.server = @server
-      @server_thread = Thread.new(Thread.current) do |master_thread|
-        begin
-          @server.serve
-        rescue => e
-          p e
-          puts e.backtrace * "\n"
-          master_thread.raise e
-        end
-      end
-      queue.pop
-
-      @clients = []
-      @catch_exceptions = false
-    end
-
-    after(:each) do
-      @clients.each { |client, trans| trans.close }
-      # @server.shutdown(1)
-      @server_thread.kill
-      @transport.close
-    end
-
-    def setup_client(queue = nil)
-      transport = SpecTransport.new(FramedTransport.new(Socket.new('localhost', @port)), queue)
-      protocol = BinaryProtocol.new(transport)
-      client = NonblockingService::Client.new(protocol)
-      transport.open
-      @clients << [client, transport]
-      client
-    end
-
-    def setup_client_thread(result)
-      queue = Queue.new
-      Thread.new do
-        begin
-          client = setup_client
-          while (cmd = queue.pop)
-            msg, *args = cmd
-            case msg
-            when :block
-              result << client.block
-            when :unblock
-              client.unblock(args.first)
-            when :hello
-              result << client.greeting(true) # ignore result
-            when :sleep
-              client.sleep(args[0] || 0.5)
-              result << :slept
-            when :shutdown
-              client.shutdown
-            when :exit
-              result << :done
-              break
-            end
-          end
-          @clients.each { |c,t| t.close and break if c == client } #close the transport
-        rescue => e
-          raise e unless @catch_exceptions
-        end
-      end
-      queue
-    end
-
-    it "should handle basic message passing" do
-      client = setup_client
-      client.greeting(true).should == Hello.new
-      client.greeting(false).should == Hello.new(:greeting => 'Aloha!')
-      @server.shutdown
-    end
-
-    it "should handle concurrent clients" do
-      queue = Queue.new
-      trans_queue = Queue.new
-      4.times do
-        Thread.new(Thread.current) do |main_thread|
-          begin
-            queue.push setup_client(trans_queue).block
-          rescue => e
-            main_thread.raise e
-          end
-        end
-      end
-      4.times { trans_queue.pop }
-      setup_client.unblock(4)
-      4.times { queue.pop.should be_true }
-      @server.shutdown
-    end
-
-    it "should handle messages from more than 5 long-lived connections" do
-      queues = []
-      result = Queue.new
-      7.times do |i|
-        queues << setup_client_thread(result)
-        Thread.pass if i == 4 # give the server time to accept connections
-      end
-      client = setup_client
-      # block 4 connections
-      4.times { |i| queues[i] << :block }
-      queues[4] << :hello
-      queues[5] << :hello
-      queues[6] << :hello
-      3.times { result.pop.should == Hello.new }
-      client.greeting(true).should == Hello.new
-      queues[5] << [:unblock, 4]
-      4.times { result.pop.should be_true }
-      queues[2] << :hello
-      result.pop.should == Hello.new
-      client.greeting(false).should == Hello.new(:greeting => 'Aloha!')
-      7.times { queues.shift << :exit }
-      client.greeting(true).should == Hello.new
-      @server.shutdown
-    end
-
-    it "should shut down when asked" do
-      # connect first to ensure it's running
-      client = setup_client
-      client.greeting(false) # force a message pass
-      @server.shutdown
-      @server_thread.join(2).should be_an_instance_of(Thread)
-    end
-
-    it "should continue processing active messages when shutting down" do
-      result = Queue.new
-      client = setup_client_thread(result)
-      client << :sleep
-      sleep 0.1 # give the server time to start processing the client's message
-      @server.shutdown
-      @server_thread.join(2).should be_an_instance_of(Thread)
-      result.pop.should == :slept
-    end
-
-    it "should kill active messages when they don't expire while shutting down" do
-      result = Queue.new
-      client = setup_client_thread(result)
-      client << [:sleep, 10]
-      sleep 0.1 # start processing the client's message
-      @server.shutdown(1)
-      @catch_exceptions = true
-      @server_thread.join(3).should_not be_nil
-      result.should be_empty
-    end
-
-    it "should allow shutting down in response to a message" do
-      client = setup_client
-      client.greeting(true).should == Hello.new
-      client.shutdown
-      @server_thread.join(2).should_not be_nil
-    end
-  end
-end

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

@@ -1,83 +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 ThriftProcessorSpec < Spec::ExampleGroup
-  include Thrift
-
-  class ProcessorSpec
-    include Thrift::Processor
-  end
-
-  describe "Processor" do
-    before(:each) do
-      @processor = ProcessorSpec.new(mock("MockHandler"))
-      @prot = mock("MockProtocol")
-    end
-
-    def mock_trans(obj)
-      obj.should_receive(:trans).ordered.and_return do
-        mock("trans").tee do |trans|
-          trans.should_receive(:flush).ordered
-        end
-      end
-    end
-
-    it "should call process_<message> when it receives that message" do
-      @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', MessageTypes::CALL, 17]
-      @processor.should_receive(:process_testMessage).with(17, @prot, @prot).ordered
-      @processor.process(@prot, @prot).should == true
-    end
-
-    it "should raise an ApplicationException when the received message cannot be processed" do
-      @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', MessageTypes::CALL, 4]
-      @prot.should_receive(:skip).with(Types::STRUCT).ordered
-      @prot.should_receive(:read_message_end).ordered
-      @prot.should_receive(:write_message_begin).with('testMessage', MessageTypes::EXCEPTION, 4).ordered
-      ApplicationException.should_receive(:new).with(ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return do
-        mock(ApplicationException).tee do |e|
-          e.should_receive(:write).with(@prot).ordered
-        end
-      end
-      @prot.should_receive(:write_message_end).ordered
-      mock_trans(@prot)
-      @processor.process(@prot, @prot)
-    end
-
-    it "should pass args off to the args class" do
-      args_class = mock("MockArgsClass")
-      args = mock("#<MockArgsClass:mock>").tee do |args|
-        args.should_receive(:read).with(@prot).ordered
-      end
-      args_class.should_receive(:new).and_return args
-      @prot.should_receive(:read_message_end).ordered
-      @processor.read_args(@prot, args_class).should eql(args)
-    end
-
-    it "should write out a reply when asked" do
-      @prot.should_receive(:write_message_begin).with('testMessage', MessageTypes::REPLY, 23).ordered
-      result = mock("MockResult")
-      result.should_receive(:write).with(@prot).ordered
-      @prot.should_receive(:write_message_end).ordered
-      mock_trans(@prot)
-      @processor.write_result(result, @prot, 'testMessage', 23)
-    end
-  end
-end