thrift 0.23.0 → 0.25.0

data/spec/server_spec.rb

@@ -1,186 +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 'spec_helper'
-
-describe 'Server' do
-  describe Thrift::BaseServer do
-    before(:each) do
-      @processor = double("Processor")
-      @serverTrans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
-    end
-
-    it "should default to BaseTransportFactory and BinaryProtocolFactory when not specified" do
-      @server = Thrift::BaseServer.new(double("Processor"), double("BaseServerTransport"))
-      expect(@server.instance_variable_get(:'@transport_factory')).to be_an_instance_of(Thrift::BaseTransportFactory)
-      expect(@server.instance_variable_get(:'@protocol_factory')).to be_an_instance_of(Thrift::BinaryProtocolFactory)
-    end
-
-    it "should not serve" do
-      expect { @server.serve() }.to raise_error(NotImplementedError)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
-      expect(@trans).to receive(:to_s).once.and_return("trans")
-      expect(@prot).to receive(:to_s).once.and_return("prot")
-      expect(@server.to_s).to eq("server(prot(trans(serverTrans)))")
-    end
-  end
-
-  describe Thrift::SimpleServer do
-    before(:each) do
-      @processor = double("Processor")
-      @serverTrans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @client = double("Client")
-      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
-      expect(@trans).to receive(:to_s).once.and_return("trans")
-      expect(@prot).to receive(:to_s).once.and_return("prot")
-      expect(@server.to_s).to eq("simple(server(prot(trans(serverTrans))))")
-    end
-
-    it "should serve in the main thread" do
-      expect(@serverTrans).to receive(:listen).ordered
-      expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
-      expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      x = 0
-      expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then throw :stop
-        end
-      end
-      expect(@trans).to receive(:close).exactly(3).times
-      expect(@serverTrans).to receive(:close).ordered
-      expect { @server.serve }.to throw_symbol(:stop)
-    end
-  end
-
-  describe Thrift::ThreadedServer do
-    before(:each) do
-      @processor = double("Processor")
-      @serverTrans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @client = double("Client")
-      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
-      expect(@trans).to receive(:to_s).once.and_return("trans")
-      expect(@prot).to receive(:to_s).once.and_return("prot")
-      expect(@server.to_s).to eq("threaded(server(prot(trans(serverTrans))))")
-    end
-
-    it "should serve using threads" do
-      expect(@serverTrans).to receive(:listen).ordered
-      expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
-      expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      expect(Thread).to receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
-      x = 0
-      expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then throw :stop
-        end
-      end
-      expect(@trans).to receive(:close).exactly(3).times
-      expect(@serverTrans).to receive(:close).ordered
-      expect { @server.serve }.to throw_symbol(:stop)
-    end
-  end
-
-  describe Thrift::ThreadPoolServer do
-    before(:each) do
-      @processor = double("Processor")
-      @server_trans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @client = double("Client")
-      @server = described_class.new(@processor, @server_trans, @trans, @prot)
-      sleep(0.15)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@server_trans).to receive(:to_s).once.and_return("server_trans")
-      expect(@trans).to receive(:to_s).once.and_return("trans")
-      expect(@prot).to receive(:to_s).once.and_return("prot")
-      expect(@server.to_s).to eq("threadpool(server(prot(trans(server_trans))))")
-    end
-
-    it "should serve inside a thread" do
-      exception_q = @server.instance_variable_get(:@exception_q)
-      expect_any_instance_of(described_class).to receive(:serve) do
-        exception_q.push(StandardError.new('ERROR'))
-      end
-      expect { @server.rescuable_serve }.to(raise_error('ERROR'))
-      sleep(0.15)
-    end
-
-    it "should avoid running the server twice when retrying rescuable_serve" do
-      exception_q = @server.instance_variable_get(:@exception_q)
-      expect_any_instance_of(described_class).to receive(:serve) do
-        exception_q.push(StandardError.new('ERROR1'))
-        exception_q.push(StandardError.new('ERROR2'))
-      end
-      expect { @server.rescuable_serve }.to(raise_error('ERROR1'))
-      expect { @server.rescuable_serve }.to(raise_error('ERROR2'))
-    end
-
-    it "should serve using a thread pool" do
-      thread_q = double("SizedQueue")
-      exception_q = double("Queue")
-      @server.instance_variable_set(:@thread_q, thread_q)
-      @server.instance_variable_set(:@exception_q, exception_q)
-      expect(@server_trans).to receive(:listen).ordered
-      expect(thread_q).to receive(:push).with(:token)
-      expect(thread_q).to receive(:pop)
-      expect(Thread).to receive(:new).and_yield
-      expect(@server_trans).to receive(:accept).exactly(3).times.and_return(@client)
-      expect(@trans).to receive(:get_transport).exactly(3).times.and_return(@trans)
-      expect(@prot).to receive(:get_protocol).exactly(3).times.and_return(@prot)
-      x = 0
-      error = RuntimeError.new("Stopped")
-      expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then raise error
-        end
-      end
-      expect(@trans).to receive(:close).exactly(3).times
-      expect(exception_q).to receive(:push).with(error).and_throw(:stop)
-      expect(@server_trans).to receive(:close)
-      expect { @server.serve }.to(throw_symbol(:stop))
-    end
-  end
-end

data/spec/socket_spec.rb

@@ -1,67 +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 'spec_helper'
-require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
-
-describe 'Socket' do
-  describe Thrift::Socket do
-    before(:each) do
-      @socket = Thrift::Socket.new
-      @handle = double("Handle", :closed? => false)
-      allow(@handle).to receive(:close)
-      allow(@handle).to receive(:connect_nonblock)
-      allow(@handle).to receive(:setsockopt)
-      allow(::Socket).to receive(:new).and_return(@handle)
-    end
-
-    it_should_behave_like "a socket"
-
-    it "should raise a TransportException when it cannot open a socket" do
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    end
-
-    it "should open a ::Socket with default args" do
-      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
-      @socket.to_s == "socket(localhost:9090)"
-      @socket.open
-    end
-
-    it "should accept host/port options" do
-      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
-      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
-      @socket = Thrift::Socket.new('my.domain', 1234).open
-      @socket.to_s == "socket(my.domain:1234)"
-    end
-
-    it "should accept an optional timeout" do
-      allow(::Socket).to receive(:new)
-      expect(Thrift::Socket.new('localhost', 8080, 5).timeout).to eq(5)
-    end
-
-    it "should provide a reasonable to_s" do
-      allow(::Socket).to receive(:new)
-      expect(Thrift::Socket.new('myhost', 8090).to_s).to eq("socket(myhost:8090)")
-    end
-  end
-end

data/spec/socket_spec_shared.rb

@@ -1,167 +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 'spec_helper'
-
-shared_examples_for "a socket" do
-  it "should open a socket" do
-    expect(@socket.open).to eq(@handle)
-  end
-
-  it "should be open whenever it has a handle" do
-    expect(@socket).not_to be_open
-    @socket.open
-    expect(@socket).to be_open
-    @socket.handle = nil
-    expect(@socket).not_to be_open
-    @socket.handle = @handle
-    @socket.close
-    expect(@socket).not_to be_open
-  end
-
-  it "should write data to the handle" do
-    @socket.open
-    expect(@handle).to receive(:write).with("foobar")
-    @socket.write("foobar")
-    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
-    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-  end
-
-  it "should raise an error when it cannot read from the handle" do
-    @socket.open
-    expect(@handle).to receive(:readpartial).with(17).and_raise(StandardError)
-    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-  end
-
-  it "should return the data read when reading from the handle works" do
-    @socket.open
-    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
-    expect(@socket.read(17)).to eq("test data")
-  end
-
-  it "should declare itself as closed when it has an error" do
-    @socket.open
-    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
-    expect(@socket).to be_open
-    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    expect(@socket).not_to be_open
-  end
-
-  it "should raise an error when the stream is closed" do
-    @socket.open
-    allow(@handle).to receive(:closed?).and_return(true)
-    expect(@socket).not_to be_open
-    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException, "closed stream") { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    expect { @socket.read(10) }.to raise_error(Thrift::TransportException, "closed stream") { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-  end
-
-  it "should support the timeout accessor for read" do
-    @socket.timeout = 3
-    @socket.open
-    expect(@handle).to receive(:read_nonblock).with(17).and_raise(IO::EAGAINWaitReadable)
-    expect(IO).to receive(:select) do |rd, wr, err, timeout|
-      expect(rd).to eq([@handle])
-      expect(wr).to be_nil
-      expect(err).to be_nil
-      expect(timeout).to be > 0
-      expect(timeout).to be <= 3
-      [[@handle], [], []]
-    end
-    expect(@handle).to receive(:read_nonblock).with(17).and_return("test data")
-    expect(@socket.read(17)).to eq("test data")
-  end
-
-  it "should support the timeout accessor for write" do
-    @socket.timeout = 3
-    @socket.open
-    write_calls = 0
-    expect(@handle).to receive(:write_nonblock).exactly(3).times do |chunk|
-      write_calls += 1
-      case write_calls
-      when 1
-        expect(chunk).to eq("test data")
-        raise IO::EAGAINWaitWritable
-      when 2
-        expect(chunk).to eq("test data")
-        4
-      when 3
-        expect(chunk).to eq(" data")
-        5
-      end
-    end
-    expect(IO).to receive(:select) do |rd, wr, err, timeout|
-      expect(rd).to be_nil
-      expect(wr).to eq([@handle])
-      expect(err).to be_nil
-      expect(timeout).to be > 0
-      expect(timeout).to be <= 3
-      [[], [@handle], []]
-    end
-    expect(@socket.write("test data")).to eq(9)
-  end
-
-  it "should raise an error when read times out" do
-    @socket.timeout = 0.5
-    @socket.open
-    expect(@handle).to receive(:read_nonblock).with(17).and_raise(IO::EAGAINWaitReadable)
-    expect(IO).to receive(:select).once { sleep(0.6); nil }
-    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
-  end
-
-  it "should raise an error when write times out" do
-    @socket.timeout = 0.5
-    @socket.open
-    expect(@handle).to receive(:write_nonblock).with("test data").and_raise(IO::EAGAINWaitWritable)
-    expect(IO).to receive(:select).once { sleep(0.6); nil }
-    expect { @socket.write("test data") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
-  end
-
-  it "should read buffered SSL data without waiting on the raw socket again" do
-    @socket.timeout = 1
-    @socket.open
-
-    expect(@handle).to receive(:read_nonblock).with(4).ordered.and_raise(IO::EAGAINWaitReadable)
-    expect(IO).to receive(:select).once.ordered do |rd, wr, err, timeout|
-      expect(rd).to eq([@handle])
-      expect(wr).to be_nil
-      expect(err).to be_nil
-      expect(timeout).to be > 0
-      expect(timeout).to be <= 1
-      [[@handle], [], []]
-    end
-    expect(@handle).to receive(:read_nonblock).with(4).ordered.and_return("ABCD")
-    expect(@handle).to receive(:read_nonblock).with(5).ordered.and_return("12345")
-
-    expect(@socket.read(4)).to eq("ABCD")
-    expect(@socket.read(5)).to eq("12345")
-  end
-
-  it "should read without timeout using the blocking path" do
-    @socket.timeout = nil
-    @socket.open
-
-    expect(IO).not_to receive(:select)
-    expect(@handle).not_to receive(:read_nonblock)
-    expect(@handle).to receive(:readpartial).with(4).ordered.and_return("ABCD")
-    expect(@handle).to receive(:readpartial).with(5).ordered.and_return("12345")
-
-    expect(@socket.read(4)).to eq("ABCD")
-    expect(@socket.read(5)).to eq("12345")
-  end
-end

data/spec/spec_helper.rb

@@ -1,69 +0,0 @@
-# encoding: UTF-8
-#
-# 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 'rspec'
-
-$:.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 'thrift'
-
-unless Object.method_defined? :tap
-  # if Object#tap isn't defined, then add it; this should only happen in Ruby < 1.8.7
-  class Object
-    def tap(&block)
-      block.call(self)
-      self
-    end
-  end
-end
-
-RSpec.configure do |configuration|
-  configuration.before(:each) do
-    Thrift.type_checking = true
-  end
-end
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. test debug_proto 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 = Thrift::Test::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
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb/flat])
-
-if defined?(GC.verify_compaction_references) == 'method'
-  # This method was added in Ruby 3.0.0. Calling it this way asks the GC to
-  # move objects around, helping to find object movement bugs.
-  GC.verify_compaction_references(double_heap: true, toward: :empty)
-end

data/spec/ssl_server_socket_spec.rb

@@ -1,45 +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 'spec_helper'
-require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
-
-describe 'SSLServerSocket' do
-  describe Thrift::SSLServerSocket do
-    before(:each) do
-      @socket = Thrift::SSLServerSocket.new(1234)
-    end
-
-    it "should delegate to_io to the underlying SSL server handle" do
-      tcp_server = double("TCPServer")
-      ssl_server = double("SSLServer")
-
-      allow(TCPServer).to receive(:new).with(nil, 1234).and_return(tcp_server)
-      allow(OpenSSL::SSL::SSLServer).to receive(:new).with(tcp_server, nil).and_return(ssl_server)
-      allow(ssl_server).to receive(:to_io).and_return(tcp_server)
-
-      @socket.listen
-      expect(@socket.to_io).to eq(tcp_server)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@socket.to_s).to eq("ssl(socket(:1234))")
-    end
-  end
-end

data/spec/ssl_socket_spec.rb

@@ -1,87 +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 'spec_helper'
-require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
-
-describe 'SSLSocket' do
-  describe Thrift::SSLSocket do
-    before(:each) do
-      @context = OpenSSL::SSL::SSLContext.new
-      @socket = Thrift::SSLSocket.new
-      @simple_socket_handle = double("Handle", :closed? => false)
-      allow(@simple_socket_handle).to receive(:close)
-      allow(@simple_socket_handle).to receive(:connect_nonblock)
-      allow(@simple_socket_handle).to receive(:setsockopt)
-
-      @handle = double(double("SSLHandle", :connect_nonblock => true, :post_connection_check => true), :closed? => false)
-      allow(@handle).to receive(:connect_nonblock)
-      allow(@handle).to receive(:close)
-      allow(@handle).to receive(:post_connection_check)
-      allow(@handle).to receive(:to_io).and_return(@simple_socket_handle)
-
-      allow(::Socket).to receive(:new).and_return(@simple_socket_handle)
-      allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@handle)
-    end
-
-    it_should_behave_like "a socket"
-
-    it "should raise a TransportException when it cannot open a ssl socket" do
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    end
-
-    it "should open a ::Socket with default args" do
-      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_return(@handle)
-      expect(@handle).to receive(:post_connection_check).with('localhost')
-      @socket.open
-    end
-
-    it "should accept host/port options" do
-      handle = double("Handle", :connect_nonblock => true, :setsockopt => nil)
-      allow(::Socket).to receive(:new).and_return(handle)
-      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
-      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(handle, nil).and_return(@handle)
-      expect(@handle).to receive(:post_connection_check).with('my.domain')
-      Thrift::SSLSocket.new('my.domain', 1234, 6000, nil).open
-    end
-
-    it "should accept an optional timeout" do
-      expect(Thrift::SSLSocket.new('localhost', 8080, 5).timeout).to eq(5)
-    end
-
-    it "should accept an optional context" do
-      expect(Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context).to eq(@context)
-    end
-
-    it "should delegate to_io to the underlying SSL socket handle" do
-      @socket.open
-      expect(@socket.to_io).to eq(@simple_socket_handle)
-    end
-
-    it "should raise IOError when to_io is called on a closed stream" do
-      expect { @socket.to_io }.to raise_error(IOError, 'closed stream')
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(Thrift::SSLSocket.new('myhost', 8090).to_s).to eq("ssl(socket(myhost:8090))")
-    end
-  end
-end