RubyGems - poolparty - Versions diffs - 1.3.15 → 1.4.0 - Mend

poolparty 1.3.15 → 1.4.0

Files changed (1171) hide show

data/vendor/gems/thrift/spec/binary_protocol_spec_shared.rb DELETED Viewed

@@ -1,375 +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 binary protocol' do
-  before(:each) do
-    @trans = Thrift::MemoryBufferTransport.new
-    @prot = protocol_class.new(@trans)
-  end
-  it "should define the proper VERSION_1, VERSION_MASK AND TYPE_MASK" do
-    protocol_class.const_get(:VERSION_MASK).should == 0xffff0000
-    protocol_class.const_get(:VERSION_1).should == 0x80010000
-    protocol_class.const_get(:TYPE_MASK).should == 0x000000ff
-  end
-  it "should make strict_read readable" do
-    @prot.strict_read.should eql(true)
-  end
-  it "should make strict_write readable" do
-    @prot.strict_write.should eql(true)
-  end
-  it "should write the message header" do
-    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
-    @trans.read(@trans.available).should == [protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::CALL, "testMessage".size, "testMessage", 17].pack("NNa11N")
-  end
-  it "should write the message header without version when writes are not strict" do
-    @prot = protocol_class.new(@trans, true, false) # no strict write
-    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
-    @trans.read(@trans.available).should == "\000\000\000\vtestMessage\001\000\000\000\021"
-  end
-  it "should write the message header with a version when writes are strict" do
-    @prot = protocol_class.new(@trans) # strict write
-    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
-    @trans.read(@trans.available).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
-  end
-  # message footer is a noop
-  it "should write the field header" do
-    @prot.write_field_begin('foo', Thrift::Types::DOUBLE, 3)
-    @trans.read(@trans.available).should == [Thrift::Types::DOUBLE, 3].pack("cn")
-  end
-  # field footer is a noop
-  it "should write the STOP field" do
-    @prot.write_field_stop
-    @trans.read(1).should == "\000"
-  end
-  it "should write the map header" do
-    @prot.write_map_begin(Thrift::Types::STRING, Thrift::Types::LIST, 17)
-    @trans.read(@trans.available).should == [Thrift::Types::STRING, Thrift::Types::LIST, 17].pack("ccN");
-  end
-  # map footer is a noop
-  it "should write the list header" do
-    @prot.write_list_begin(Thrift::Types::I16, 42)
-    @trans.read(@trans.available).should == [Thrift::Types::I16, 42].pack("cN")
-  end
-  # list footer is a noop
-  it "should write the set header" do
-    @prot.write_set_begin(Thrift::Types::I16, 42)
-    @trans.read(@trans.available).should == [Thrift::Types::I16, 42].pack("cN")
-  end
-  it "should write a bool" do
-    @prot.write_bool(true)
-    @prot.write_bool(false)
-    @trans.read(@trans.available).should == "\001\000"
-  end
-  it "should treat a nil bool as false" do
-    @prot.write_bool(nil)
-    @trans.read(1).should == "\000"
-  end
-  it "should write a byte" do
-    # byte is small enough, let's check -128..127
-    (-128..127).each do |i|
-      @prot.write_byte(i)
-      @trans.read(1).should == [i].pack('c')
-    end
-    # handing it numbers out of signed range should clip
-    @trans.rspec_verify
-    (128..255).each do |i|
-      @prot.write_byte(i)
-      @trans.read(1).should == [i].pack('c')
-    end
-    # and lastly, a Bignum is going to error out
-    lambda { @prot.write_byte(2**65) }.should raise_error(RangeError)
-  end
-  it "should error gracefully when trying to write a nil byte" do
-    lambda { @prot.write_byte(nil) }.should raise_error
-  end
-  it "should write an i16" do
-    # try a random scattering of values
-    # include the signed i16 minimum/maximum
-    [-2**15, -1024, 17, 0, -10000, 1723, 2**15-1].each do |i|
-      @prot.write_i16(i)
-    end
-    # and try something out of signed range, it should clip
-    @prot.write_i16(2**15 + 5)
-    @trans.read(@trans.available).should == "\200\000\374\000\000\021\000\000\330\360\006\273\177\377\200\005"
-    # a Bignum should error
-    # lambda { @prot.write_i16(2**65) }.should raise_error(RangeError)
-  end
-  it "should error gracefully when trying to write a nil i16" do
-    lambda { @prot.write_i16(nil) }.should raise_error
-  end
-  it "should write an i32" do
-    # try a random scattering of values
-    # include the signed i32 minimum/maximum
-    [-2**31, -123123, -2532, -3, 0, 2351235, 12331, 2**31-1].each do |i|
-      @prot.write_i32(i)
-    end
-    # try something out of signed range, it should clip
-    @trans.read(@trans.available).should == "\200\000\000\000" + "\377\376\037\r" + "\377\377\366\034" + "\377\377\377\375" + "\000\000\000\000" + "\000#\340\203" + "\000\0000+" + "\177\377\377\377"
-    [2 ** 31 + 5, 2 ** 65 + 5].each do |i|
-      lambda { @prot.write_i32(i) }.should raise_error(RangeError)
-    end
-  end
-  it "should error gracefully when trying to write a nil i32" do
-    lambda { @prot.write_i32(nil) }.should raise_error
-  end
-  it "should write an i64" do
-    # try a random scattering of values
-    # try the signed i64 minimum/maximum
-    [-2**63, -12356123612323, -23512351, -234, 0, 1231, 2351236, 12361236213, 2**63-1].each do |i|
-      @prot.write_i64(i)
-    end
-    # try something out of signed range, it should clip
-    @trans.read(@trans.available).should == ["\200\000\000\000\000\000\000\000",
-      "\377\377\364\303\035\244+]",
-      "\377\377\377\377\376\231:\341",
-      "\377\377\377\377\377\377\377\026",
-      "\000\000\000\000\000\000\000\000",
-      "\000\000\000\000\000\000\004\317",
-      "\000\000\000\000\000#\340\204",
-      "\000\000\000\002\340\311~\365",
-      "\177\377\377\377\377\377\377\377"].join("")
-    lambda { @prot.write_i64(2 ** 65 + 5) }.should raise_error(RangeError)
-  end
-  it "should error gracefully when trying to write a nil i64" do
-    lambda { @prot.write_i64(nil) }.should raise_error
-  end
-  it "should write a double" do
-    # try a random scattering of values, including min/max
-    values = [Float::MIN,-1231.15325, -123123.23, -23.23515123, 0, 12351.1325, 523.23, Float::MAX]
-    values.each do |f|
-      @prot.write_double(f)
-      @trans.read(@trans.available).should == [f].pack("G")
-    end
-  end
-  it "should error gracefully when trying to write a nil double" do
-    lambda { @prot.write_double(nil) }.should raise_error
-  end
-  it "should write a string" do
-    str = "hello world"
-    @prot.write_string(str)
-    @trans.read(@trans.available).should == [str.size].pack("N") + str
-  end
-  it "should error gracefully when trying to write a nil string" do
-    lambda { @prot.write_string(nil) }.should raise_error
-  end
-  it "should write the message header without version when writes are not strict" do
-    @prot = protocol_class.new(@trans, true, false) # no strict write
-    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
-    @trans.read(@trans.available).should == "\000\000\000\vtestMessage\001\000\000\000\021"
-  end
-  it "should write the message header with a version when writes are strict" do
-    @prot = protocol_class.new(@trans) # strict write
-    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
-    @trans.read(@trans.available).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
-  end
-  # message footer is a noop
-  it "should read a field header" do
-    @trans.write([Thrift::Types::STRING, 3].pack("cn"))
-    @prot.read_field_begin.should == [nil, Thrift::Types::STRING, 3]
-  end
-  # field footer is a noop
-  it "should read a stop field" do
-    @trans.write([Thrift::Types::STOP].pack("c"));
-    @prot.read_field_begin.should == [nil, Thrift::Types::STOP, 0]
-  end
-  it "should read a map header" do
-    @trans.write([Thrift::Types::DOUBLE, Thrift::Types::I64, 42].pack("ccN"))
-    @prot.read_map_begin.should == [Thrift::Types::DOUBLE, Thrift::Types::I64, 42]
-  end
-  # map footer is a noop
-  it "should read a list header" do
-    @trans.write([Thrift::Types::STRING, 17].pack("cN"))
-    @prot.read_list_begin.should == [Thrift::Types::STRING, 17]
-  end
-  # list footer is a noop
-  it "should read a set header" do
-    @trans.write([Thrift::Types::STRING, 17].pack("cN"))
-    @prot.read_set_begin.should == [Thrift::Types::STRING, 17]
-  end
-  # set footer is a noop
-  it "should read a bool" do
-    @trans.write("\001\000");
-    @prot.read_bool.should == true
-    @prot.read_bool.should == false
-  end
-  it "should read a byte" do
-    [-128, -57, -3, 0, 17, 24, 127].each do |i|
-      @trans.write([i].pack("c"))
-      @prot.read_byte.should == i
-    end
-  end
-  it "should read an i16" do
-    # try a scattering of values, including min/max
-    [-2**15, -5237, -353, 0, 1527, 2234, 2**15-1].each do |i|
-      @trans.write([i].pack("n"));
-      @prot.read_i16.should == i
-    end
-  end
-  it "should read an i32" do
-    # try a scattering of values, including min/max
-    [-2**31, -235125, -6236, 0, 2351, 123123, 2**31-1].each do |i|
-      @trans.write([i].pack("N"))
-      @prot.read_i32.should == i
-    end
-  end
-  it "should read an i64" do
-    # try a scattering of values, including min/max
-    [-2**63, -123512312, -6346, 0, 32, 2346322323, 2**63-1].each do |i|
-      @trans.write([i >> 32, i & 0xFFFFFFFF].pack("NN"))
-      @prot.read_i64.should == i
-    end
-  end
-  it "should read a double" do
-    # try a random scattering of values, including min/max
-    [Float::MIN, -231231.12351, -323.233513, 0, 123.2351235, 2351235.12351235, Float::MAX].each do |f|
-      @trans.write([f].pack("G"));
-      @prot.read_double.should == f
-    end
-  end
-  it "should read a string" do
-    str = "hello world"
-    @trans.write([str.size].pack("N") + str)
-    @prot.read_string.should == str
-  end
-  it "should perform a complete rpc with no args or return" do
-    srv_test(
-      proc {|client| client.send_voidMethod()},
-      proc {|client| client.recv_voidMethod.should == nil}
-    )
-  end
-  it "should perform a complete rpc with a primitive return type" do
-    srv_test(
-      proc {|client| client.send_primitiveMethod()},
-      proc {|client| client.recv_primitiveMethod.should == 1}
-    )
-  end
-  it "should perform a complete rpc with a struct return type" do
-    srv_test(
-      proc {|client| client.send_structMethod()},
-      proc {|client|
-        result = client.recv_structMethod
-        result.set_byte_map = nil
-        result.map_byte_map = nil
-        result.should == Fixtures::COMPACT_PROTOCOL_TEST_STRUCT
-      }
-    )
-  end
-  def get_socket_connection
-    server = Thrift::ServerSocket.new("localhost", 9090)
-    server.listen
-    clientside = Thrift::Socket.new("localhost", 9090)
-    clientside.open
-    serverside = server.accept
-    [clientside, serverside, server]
-  end
-  def srv_test(firstblock, secondblock)
-    clientside, serverside, server = get_socket_connection
-    clientproto = protocol_class.new(clientside)
-    serverproto = protocol_class.new(serverside)
-    processor = Srv::Processor.new(SrvHandler.new)
-    client = Srv::Client.new(clientproto, clientproto)
-    # first block
-    firstblock.call(client)
-    processor.process(serverproto, serverproto)
-    # second block
-    secondblock.call(client)
-  ensure
-    clientside.close
-    serverside.close
-    server.close
-  end
-  class SrvHandler
-    def voidMethod()
-    end
-    def primitiveMethod
-      1
-    end
-    def structMethod
-      Fixtures::COMPACT_PROTOCOL_TEST_STRUCT
-    end
-  end
-end

data/vendor/gems/thrift/spec/client_spec.rb DELETED Viewed

@@ -1,100 +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 ThriftClientSpec < Spec::ExampleGroup
-  include Thrift
-  class ClientSpec
-    include Thrift::Client
-  end
-  before(:each) do
-    @prot = mock("MockProtocol")
-    @client = ClientSpec.new(@prot)
-  end
-  describe Client do
-    it "should re-use iprot for oprot if not otherwise specified" do
-      @client.instance_variable_get(:'@iprot').should eql(@prot)
-      @client.instance_variable_get(:'@oprot').should eql(@prot)
-    end
-    it "should send a test message" do
-      @prot.should_receive(:write_message_begin).with('testMessage', MessageTypes::CALL, 0)
-      mock_args = mock('#<TestMessage_args:mock>')
-      mock_args.should_receive(:foo=).with('foo')
-      mock_args.should_receive(:bar=).with(42)
-      mock_args.should_receive(:write).with(@prot)
-      @prot.should_receive(:write_message_end)
-      @prot.should_receive(:trans) do
-        mock('trans').tee do |trans|
-          trans.should_receive(:flush)
-        end
-      end
-      klass = stub("TestMessage_args", :new => mock_args)
-      @client.send_message('testMessage', klass, :foo => 'foo', :bar => 42)
-    end
-    it "should increment the sequence id when sending messages" do
-      pending "it seems sequence ids are completely ignored right now" do
-        @prot.should_receive(:write_message_begin).with('testMessage',  MessageTypes::CALL, 0).ordered
-        @prot.should_receive(:write_message_begin).with('testMessage2', MessageTypes::CALL, 1).ordered
-        @prot.should_receive(:write_message_begin).with('testMessage3', MessageTypes::CALL, 2).ordered
-        @prot.stub!(:write_message_end)
-        @prot.stub!(:trans).and_return mock("trans").as_null_object
-        @client.send_message('testMessage', mock("args class").as_null_object)
-        @client.send_message('testMessage2', mock("args class").as_null_object)
-        @client.send_message('testMessage3', mock("args class").as_null_object)
-      end
-    end
-    it "should receive a test message" do
-      @prot.should_receive(:read_message_begin).and_return [nil, MessageTypes::CALL, 0]
-      @prot.should_receive(:read_message_end)
-      mock_klass = mock("#<MockClass:mock>")
-      mock_klass.should_receive(:read).with(@prot)
-      @client.receive_message(stub("MockClass", :new => mock_klass))
-    end
-    it "should handle received exceptions" do
-      @prot.should_receive(:read_message_begin).and_return [nil, MessageTypes::EXCEPTION, 0]
-      @prot.should_receive(:read_message_end)
-      ApplicationException.should_receive(:new).and_return do
-        StandardError.new.tee do |mock_exc|
-          mock_exc.should_receive(:read).with(@prot)
-        end
-      end
-      lambda { @client.receive_message(nil) }.should raise_error(StandardError)
-    end
-    it "should close the transport if an error occurs while sending a message" do
-      @prot.stub!(:write_message_begin)
-      @prot.should_not_receive(:write_message_end)
-      mock_args = mock("#<TestMessage_args:mock>")
-      mock_args.should_receive(:write).with(@prot).and_raise(StandardError)
-      trans = mock("MockTransport")
-      @prot.stub!(:trans).and_return(trans)
-      trans.should_receive(:close)
-      klass = mock("TestMessage_args", :new => mock_args)
-      lambda { @client.send_message("testMessage", klass) }.should raise_error(StandardError)
-    end
-  end
-end

data/vendor/gems/thrift/spec/compact_protocol_spec.rb DELETED Viewed

@@ -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'
-describe Thrift::CompactProtocol do
-  TESTS = {
-    :byte => (-127..127).to_a,
-    :i16 => (0..14).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort,
-    :i32 => (0..30).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort,
-    :i64 => (0..62).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort,
-    :string => ["", "1", "short", "fourteen123456", "fifteen12345678", "1" * 127, "1" * 3000],
-    :binary => ["", "\001", "\001" * 5, "\001" * 14, "\001" * 15, "\001" * 127, "\001" * 3000],
-    :double => [0.0, 1.0, -1.0, 1.1, -1.1, 10000000.1, 1.0/0.0, -1.0/0.0],
-    :bool => [true, false]
-  }
-  it "should encode and decode naked primitives correctly" do
-    TESTS.each_pair do |primitive_type, test_values|
-      test_values.each do |value|
-        # puts "testing #{value}" if primitive_type == :i64
-        trans = Thrift::MemoryBufferTransport.new
-        proto = Thrift::CompactProtocol.new(trans)
-        proto.send(writer(primitive_type), value)
-        # puts "buf: #{trans.inspect_buffer}" if primitive_type == :i64
-        read_back = proto.send(reader(primitive_type))
-        read_back.should == value
-      end
-    end
-  end
-  it "should encode and decode primitives in fields correctly" do
-    TESTS.each_pair do |primitive_type, test_values|
-      final_primitive_type = primitive_type == :binary ? :string : primitive_type
-      thrift_type = Thrift::Types.const_get(final_primitive_type.to_s.upcase)
-      # puts primitive_type
-      test_values.each do |value|
-        trans = Thrift::MemoryBufferTransport.new
-        proto = Thrift::CompactProtocol.new(trans)
-        proto.write_field_begin(nil, thrift_type, 15)
-        proto.send(writer(primitive_type), value)
-        proto.write_field_end
-        proto = Thrift::CompactProtocol.new(trans)
-        name, type, id = proto.read_field_begin
-        type.should == thrift_type
-        id.should == 15
-        read_back = proto.send(reader(primitive_type))
-        read_back.should == value
-        proto.read_field_end
-      end
-    end
-  end
-  it "should encode and decode a monster struct correctly" do
-    trans = Thrift::MemoryBufferTransport.new
-    proto = Thrift::CompactProtocol.new(trans)
-    struct = CompactProtoTestStruct.new
-    # sets and maps don't hash well... not sure what to do here.
-    struct.write(proto)
-    struct2 = CompactProtoTestStruct.new
-    struct2.read(proto)
-    struct2.should == struct
-  end
-  it "should make method calls correctly" do
-    client_out_trans = Thrift::MemoryBufferTransport.new
-    client_out_proto = Thrift::CompactProtocol.new(client_out_trans)
-    client_in_trans = Thrift::MemoryBufferTransport.new
-    client_in_proto = Thrift::CompactProtocol.new(client_in_trans)
-    processor = Srv::Processor.new(JankyHandler.new)
-    client = Srv::Client.new(client_in_proto, client_out_proto)
-    client.send_Janky(1)
-    # puts client_out_trans.inspect_buffer
-    processor.process(client_out_proto, client_in_proto)
-    client.recv_Janky.should == 2
-  end
-  class JankyHandler
-    def Janky(i32arg)
-      i32arg * 2
-    end
-  end
-  def writer(sym)
-    sym = sym == :binary ? :string : sym
-    "write_#{sym.to_s}"
-  end
-  def reader(sym)
-    sym = sym == :binary ? :string : sym
-    "read_#{sym.to_s}"
-  end
-end