thrift 0.23.0 → 0.25.0

data/spec/thin_http_server_spec.rb

@@ -1,126 +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 'rack/test'
-require 'thrift/server/thin_http_server'
-
-describe Thrift::ThinHTTPServer do
-  let(:processor) { double('processor') }
-
-  describe "#initialize" do
-    context "when using the defaults" do
-      it "binds to port 80, with host 0.0.0.0, a path of '/'" do
-        expect(Thin::Server).to receive(:new).with('0.0.0.0', 80, an_instance_of(Rack::Builder))
-        Thrift::ThinHTTPServer.new(processor)
-      end
-
-      it 'creates a ThinHTTPServer::RackApplicationContext' do
-        expect(Thrift::ThinHTTPServer::RackApplication).to receive(:for).with("/", processor, an_instance_of(Thrift::BinaryProtocolFactory)).and_return(anything)
-        Thrift::ThinHTTPServer.new(processor)
-      end
-
-      it "uses the BinaryProtocolFactory" do
-        expect(Thrift::BinaryProtocolFactory).to receive(:new)
-        Thrift::ThinHTTPServer.new(processor)
-      end
-    end
-
-    context "when using the options" do
-      it 'accepts :ip, :port, :path' do
-        ip = "192.168.0.1"
-        port = 3000
-        path = "/thin"
-        expect(Thin::Server).to receive(:new).with(ip, port, an_instance_of(Rack::Builder))
-        Thrift::ThinHTTPServer.new(processor,
-                           :ip => ip,
-                           :port => port,
-                           :path => path)
-      end
-
-      it 'creates a ThinHTTPServer::RackApplicationContext with a different protocol factory' do
-        expect(Thrift::ThinHTTPServer::RackApplication).to receive(:for).with("/", processor, an_instance_of(Thrift::JsonProtocolFactory)).and_return(anything)
-        Thrift::ThinHTTPServer.new(processor,
-                           :protocol_factory => Thrift::JsonProtocolFactory.new)
-      end
-    end
-  end
-
-  describe "#serve" do
-    it 'starts the Thin server' do
-      underlying_thin_server = double('thin server', :start => true)
-      allow(Thin::Server).to receive(:new).and_return(underlying_thin_server)
-
-      thin_thrift_server = Thrift::ThinHTTPServer.new(processor)
-
-      expect(underlying_thin_server).to receive(:start)
-      thin_thrift_server.serve
-    end
-  end
-end
-
-describe Thrift::ThinHTTPServer::RackApplication do
-  include Rack::Test::Methods
-
-  let(:processor) { double('processor') }
-  let(:protocol_factory) { double('protocol factory') }
-
-  def app
-    Thrift::ThinHTTPServer::RackApplication.for("/", processor, protocol_factory)
-  end
-
-  context "404 response" do
-    it 'receives a non-POST' do
-      header('Content-Type', "application/x-thrift")
-      get "/"
-      expect(last_response.status).to eq 404
-    end
-
-    it 'receives a header other than application/x-thrift' do
-      header('Content-Type', "application/json")
-      post "/"
-      expect(last_response.status).to eq 404
-    end
-  end
-
-  context "200 response" do
-    before do
-      allow(protocol_factory).to receive(:get_protocol)
-      allow(processor).to receive(:process)
-    end
-
-    it 'creates an IOStreamTransport' do
-      header('Content-Type', "application/x-thrift")
-      expect(Thrift::IOStreamTransport).to receive(:new).with(an_instance_of(Rack::Lint::InputWrapper), an_instance_of(Rack::Response))
-      post "/"
-    end
-
-    it 'fetches the right protocol based on the Transport' do
-      header('Content-Type', "application/x-thrift")
-      expect(protocol_factory).to receive(:get_protocol).with(an_instance_of(Thrift::IOStreamTransport))
-      post "/"
-    end
-
-    it 'status code 200' do
-      header('Content-Type', "application/x-thrift")
-      post "/"
-      expect(last_response.ok?).to be true
-    end
-  end
-end

data/spec/types_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 'spec_helper'
-
-describe Thrift::Types do
-  before(:each) do
-    Thrift.type_checking = true
-  end
-
-  after(:each) do
-    Thrift.type_checking = false
-  end
-
-  context 'type checking' do
-    it "should return the proper name for each type" do
-      expect(Thrift.type_name(Thrift::Types::I16)).to eq("Types::I16")
-      expect(Thrift.type_name(Thrift::Types::VOID)).to eq("Types::VOID")
-      expect(Thrift.type_name(Thrift::Types::LIST)).to eq("Types::LIST")
-      expect(Thrift.type_name(42)).to be_nil
-    end
-
-    it "should check types properly" do
-      # lambda { Thrift.check_type(nil, Thrift::Types::STOP) }.should raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(3,               {:type => Thrift::Types::STOP},   :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil,             {:type => Thrift::Types::VOID},   :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,               {:type => Thrift::Types::VOID},   :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(true,            {:type => Thrift::Types::BOOL},   :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,               {:type => Thrift::Types::BOOL},   :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(42,              {:type => Thrift::Types::BYTE},   :foo) }.not_to raise_error
-      expect { Thrift.check_type(42,              {:type => Thrift::Types::I16},    :foo) }.not_to raise_error
-      expect { Thrift.check_type(42,              {:type => Thrift::Types::I32},    :foo) }.not_to raise_error
-      expect { Thrift.check_type(42,              {:type => Thrift::Types::I64},    :foo) }.not_to raise_error
-      expect { Thrift.check_type(3.14,            {:type => Thrift::Types::I32},    :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(3.14,            {:type => Thrift::Types::DOUBLE}, :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,               {:type => Thrift::Types::DOUBLE}, :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type("3",             {:type => Thrift::Types::STRING}, :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,               {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError)
-      hello = SpecNamespace::Hello.new
-      expect { Thrift.check_type(hello,           {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.not_to raise_error
-      expect { Thrift.check_type("foo",           {:type => Thrift::Types::STRUCT}, :foo) }.to raise_error(Thrift::TypeError)
-      field = {:type => Thrift::Types::MAP, :key => {:type => Thrift::Types::I32}, :value => {:type => Thrift::Types::STRING}}
-      expect { Thrift.check_type({1 => "one"},    field,                            :foo) }.not_to raise_error
-      expect { Thrift.check_type([1],             field,                            :foo) }.to raise_error(Thrift::TypeError)
-      field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::I32}}
-      expect { Thrift.check_type([1],             field,                            :foo) }.not_to raise_error
-      expect { Thrift.check_type({:foo => 1},     field,                            :foo) }.to raise_error(Thrift::TypeError)
-      field = {:type => Thrift::Types::SET, :element => {:type => Thrift::Types::I32}}
-      expect { Thrift.check_type(Set.new([1, 2]), field,                            :foo) }.not_to raise_error
-      expect { Thrift.check_type([1, 2],          field,                            :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type({:foo => true},  field,                            :foo) }.to raise_error(Thrift::TypeError)
-    end
-
-    it "should error out if nil is passed and skip_types is false" do
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::BOOL},   :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::BYTE},   :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::I16},    :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::I32},    :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::I64},    :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::DOUBLE}, :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::STRING}, :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::STRUCT}, :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::LIST},   :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::SET},    :foo, false) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil, {:type => Thrift::Types::MAP},    :foo, false) }.to raise_error(Thrift::TypeError)
-    end
-
-    it "should check element types on containers" do
-      field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::I32}}
-      expect { Thrift.check_type([1, 2], field, :foo) }.not_to raise_error
-      expect { Thrift.check_type([1, nil, 2], field, :foo) }.to raise_error(Thrift::TypeError)
-      field = {:type => Thrift::Types::MAP, :key => {:type => Thrift::Types::I32}, :value => {:type => Thrift::Types::STRING}}
-      expect { Thrift.check_type({1 => "one", 2 => "two"}, field, :foo) }.not_to raise_error
-      expect { Thrift.check_type({1 => "one", nil => "nil"}, field, :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type({1 => nil, 2 => "two"}, field, :foo) }.to raise_error(Thrift::TypeError)
-      field = {:type => Thrift::Types::SET, :element => {:type => Thrift::Types::I32}}
-      expect { Thrift.check_type(Set.new([1, 2]), field, :foo) }.not_to raise_error
-      expect { Thrift.check_type(Set.new([1, nil, 2]), field, :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(Set.new([1, 2.3, 2]), field, :foo) }.to raise_error(Thrift::TypeError)
-
-      field = {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}
-      expect { Thrift.check_type(SpecNamespace::BoolStruct, field, :foo) }.to raise_error(Thrift::TypeError)
-    end
-
-    it "should give the Thrift::TypeError a readable message" do
-      msg = "Expected Types::STRING, received Integer for field foo"
-      expect { Thrift.check_type(3, {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError, msg)
-      msg = "Expected Types::STRING, received Integer for field foo.element"
-      field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::STRING}}
-      expect { Thrift.check_type([3], field, :foo) }.to raise_error(Thrift::TypeError, msg)
-      msg = "Expected Types::I32, received NilClass for field foo.element.key"
-      field = {:type => Thrift::Types::LIST,
-               :element => {:type => Thrift::Types::MAP,
-                            :key => {:type => Thrift::Types::I32},
-                            :value => {:type => Thrift::Types::I32}}}
-      expect { Thrift.check_type([{nil => 3}], field, :foo) }.to raise_error(Thrift::TypeError, msg)
-      msg = "Expected Types::I32, received NilClass for field foo.element.value"
-      expect { Thrift.check_type([{1 => nil}], field, :foo) }.to raise_error(Thrift::TypeError, msg)
-    end
-  end
-end

data/spec/union_spec.rb

@@ -1,272 +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 'Union' do
-  describe Thrift::Union do
-    it "should return nil value in unset union" do
-      union = SpecNamespace::My_union.new
-      expect(union.get_set_field).to eq(nil)
-      expect(union.get_value).to eq(nil)
-    end
-
-    it "should set a field and be accessible through get_value and the named field accessor" do
-      union = SpecNamespace::My_union.new
-      union.integer32 = 25
-      expect(union.get_set_field).to eq(:integer32)
-      expect(union.get_value).to eq(25)
-      expect(union.integer32).to eq(25)
-    end
-
-    it "should work correctly when instantiated with static field constructors" do
-      union = SpecNamespace::My_union.integer32(5)
-      expect(union.get_set_field).to eq(:integer32)
-      expect(union.integer32).to eq(5)
-    end
-
-    it "should raise for wrong set field" do
-      union = SpecNamespace::My_union.new
-      union.integer32 = 25
-      expect { union.some_characters }.to raise_error(RuntimeError, "some_characters is not union's set field.")
-    end
-
-    it "should raise for wrong set field when hash initialized and type checking is off" do
-      Thrift.type_checking = false
-      union = SpecNamespace::My_union.new({incorrect_field: :incorrect})
-      expect { Thrift::Serializer.new.serialize(union) }.to raise_error(Thrift::ProtocolException, "set_field is not valid for this union!") { |error|
-        expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
-      }
-    end
-
-    it "should not be equal to nil" do
-      union = SpecNamespace::My_union.new
-      expect(union).not_to eq(nil)
-    end
-
-    it "should not be equal with an empty String" do
-      union = SpecNamespace::My_union.new
-      expect(union).not_to eq('')
-    end
-
-    it "should not equate two different unions, i32 vs. string" do
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      other_union = SpecNamespace::My_union.new(:some_characters, "blah!")
-      expect(union).not_to eq(other_union)
-    end
-
-    it "should properly reset setfield and setvalue" do
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      expect(union.get_set_field).to eq(:integer32)
-      union.some_characters = "blah!"
-      expect(union.get_set_field).to eq(:some_characters)
-      expect(union.get_value).to eq("blah!")
-      expect { union.integer32 }.to raise_error(RuntimeError, "integer32 is not union's set field.")
-    end
-
-    it "should not equate two different unions with different values" do
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      other_union = SpecNamespace::My_union.new(:integer32, 400)
-      expect(union).not_to eq(other_union)
-    end
-
-    it "should not equate two different unions with different fields" do
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      other_union = SpecNamespace::My_union.new(:other_i32, 25)
-      expect(union).not_to eq(other_union)
-    end
-
-    it "should equate two unions with the same UUID value" do
-      union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
-      other_union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
-      expect(union).to eq(other_union)
-    end
-
-    it "should not equate two unions with different UUID values" do
-      union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
-      other_union = SpecNamespace::My_union.new(:unique_id, '6ba7b810-9dad-11d1-80b4-00c04fd430c8')
-      expect(union).not_to eq(other_union)
-    end
-
-    it "should not equate UUID union with different field type" do
-      union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
-      other_union = SpecNamespace::My_union.new(:some_characters, '550e8400-e29b-41d4-a716-446655440000')
-      expect(union).not_to eq(other_union)
-    end
-
-    it "should inspect properly" do
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      expect(union.inspect).to eq("<SpecNamespace::My_union integer32: 25>")
-    end
-
-    it "should not allow setting with instance_variable_set" do
-      union = SpecNamespace::My_union.new(:integer32, 27)
-      union.instance_variable_set(:@some_characters, "hallo!")
-      expect(union.get_set_field).to eq(:integer32)
-      expect(union.get_value).to eq(27)
-      expect { union.some_characters }.to raise_error(RuntimeError, "some_characters is not union's set field.")
-    end
-
-    it "should serialize to binary correctly" do
-      trans = Thrift::MemoryBufferTransport.new
-      proto = Thrift::BinaryProtocol.new(trans)
-
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      union.write(proto)
-
-      other_union = SpecNamespace::My_union.new(:integer32, 25)
-      other_union.read(proto)
-      expect(other_union).to eq(union)
-    end
-
-    it "should serialize to json correctly" do
-      trans = Thrift::MemoryBufferTransport.new
-      proto = Thrift::JsonProtocol.new(trans)
-
-      union = SpecNamespace::My_union.new(:integer32, 25)
-      union.write(proto)
-
-      other_union = SpecNamespace::My_union.new(:integer32, 25)
-      other_union.read(proto)
-      expect(other_union).to eq(union)
-    end
-
-    it "should raise when validating unset union" do
-      union = SpecNamespace::My_union.new
-      expect { union.validate }.to raise_error(Thrift::ProtocolException, "Union fields are not set.") { |error|
-        expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
-      }
-
-      other_union = SpecNamespace::My_union.new(:integer32, 1)
-      expect { other_union.validate }.not_to raise_error
-    end
-
-    it "should validate an enum field properly" do
-      union = SpecNamespace::TestUnion.new(:enum_field, 3)
-      expect(union.get_set_field).to eq(:enum_field)
-      expect { union.validate }.to raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!") { |error|
-        expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
-      }
-
-      other_union = SpecNamespace::TestUnion.new(:enum_field, 1)
-      expect { other_union.validate }.not_to raise_error
-    end
-
-    it "should properly serialize and match structs with a union" do
-      union = SpecNamespace::My_union.new(:integer32, 26)
-      swu = SpecNamespace::Struct_with_union.new(:fun_union => union)
-
-      trans = Thrift::MemoryBufferTransport.new
-      proto = Thrift::CompactProtocol.new(trans)
-
-      swu.write(proto)
-
-      other_union = SpecNamespace::My_union.new(:some_characters, "hello there")
-      swu2 = SpecNamespace::Struct_with_union.new(:fun_union => other_union)
-
-      expect(swu2).not_to eq(swu)
-
-      swu2.read(proto)
-      expect(swu2).to eq(swu)
-    end
-
-    it "should support old style constructor" do
-      union = SpecNamespace::My_union.new(:integer32 => 26)
-      expect(union.get_set_field).to eq(:integer32)
-      expect(union.get_value).to eq(26)
-    end
-
-    it "should not throw an error when inspected and unset" do
-      expect{ SpecNamespace::TestUnion.new().inspect }.not_to raise_error
-    end
-
-    it "should print enum value name when inspected" do
-      expect(SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect).to eq("<SpecNamespace::My_union some_enum: ONE (0)>")
-
-      expect(SpecNamespace::My_union.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect).to eq("<SpecNamespace::My_union my_map: {ONE (0): [TWO (1)]}>")
-    end
-
-    it "should offer field? methods" do
-      expect(SpecNamespace::My_union.new.some_enum?).to be_falsey
-      expect(SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).some_enum?).to be_truthy
-      expect(SpecNamespace::My_union.new(:im_true => false).im_true?).to be_truthy
-      expect(SpecNamespace::My_union.new(:im_true => true).im_true?).to be_truthy
-    end
-
-    it "should pretty print binary fields" do
-      expect(SpecNamespace::TestUnion.new(:binary_field => "\001\002\003").inspect).to eq("<SpecNamespace::TestUnion binary_field: 010203>")
-    end
-
-    it "should be comparable" do
-      relationships = [
-        [0,   -1, -1, -1, -1, -1],
-        [1,   0,  -1, -1, -1, -1],
-        [1,   1,  0,  -1, -1, -1],
-        [1,   1,  1,  0,  -1, -1],
-        [1,   1,  1,  1,  0,  -1],
-        [1,   1,  1,  1,  1,  0]]
-
-      objs = [
-        SpecNamespace::TestUnion.new(:string_field, "blah"),
-        SpecNamespace::TestUnion.new(:string_field, "blahblah"),
-        SpecNamespace::TestUnion.new(:i32_field, 1),
-        SpecNamespace::TestUnion.new(:uuid_field, '550e8400-e29b-41d4-a716-446655440000'),
-        SpecNamespace::TestUnion.new(:uuid_field, '6ba7b810-9dad-11d1-80b4-00c04fd430c8'),
-        SpecNamespace::TestUnion.new()]
-
-      objs.size.times do |y|
-        objs.size.times do |x|
-          # puts "#{objs[y].inspect} <=> #{objs[x].inspect} should == #{relationships[y][x]}"
-          expect(objs[y] <=> objs[x]).to eq(relationships[y][x])
-        end
-      end
-    end
-
-    it "should handle UUID as union value" do
-      union = SpecNamespace::My_union.new
-      union.unique_id = 'ffffffff-ffff-ffff-ffff-ffffffffffff'
-
-      trans = Thrift::MemoryBufferTransport.new
-      prot = Thrift::CompactProtocol.new(trans)
-
-      union.write(prot)
-
-      result = SpecNamespace::My_union.new
-      result.read(prot)
-
-      expect(result.unique_id).to eq('ffffffff-ffff-ffff-ffff-ffffffffffff')
-      expect(result.get_set_field).to eq(:unique_id)
-    end
-
-    it "should normalize UUID case in union" do
-      union = SpecNamespace::My_union.new
-      union.unique_id = '550E8400-E29B-41D4-A716-446655440000'
-
-      trans = Thrift::MemoryBufferTransport.new
-      prot = Thrift::BinaryProtocol.new(trans)
-
-      union.write(prot)
-
-      result = SpecNamespace::My_union.new
-      result.read(prot)
-
-      expect(result.unique_id).to eq('550e8400-e29b-41d4-a716-446655440000')
-    end
-  end
-end

data/spec/unix_socket_spec.rb

@@ -1,115 +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 'UNIXSocket' do
-  describe Thrift::UNIXSocket do
-    before(:each) do
-      @path = '/tmp/thrift_spec_socket'
-      @socket = Thrift::UNIXSocket.new(@path)
-      @handle = double("Handle", :closed? => false)
-      allow(@handle).to receive(:close)
-      allow(::UNIXSocket).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(::UNIXSocket).to receive(:new).and_raise(StandardError)
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    end
-
-    it "should accept an optional timeout" do
-      allow(::UNIXSocket).to receive(:new)
-      expect(Thrift::UNIXSocket.new(@path, 5).timeout).to eq(5)
-    end
-
-    it "should provide a reasonable to_s" do
-      allow(::UNIXSocket).to receive(:new)
-      expect(Thrift::UNIXSocket.new(@path).to_s).to eq("domain(#{@path})")
-    end
-  end
-
-  describe Thrift::UNIXServerSocket do
-    before(:each) do
-      @path = '/tmp/thrift_spec_socket'
-      @socket = Thrift::UNIXServerSocket.new(@path)
-    end
-
-    it "should create a handle when calling listen" do
-      expect(UNIXServer).to receive(:new).with(@path)
-      @socket.listen
-    end
-
-    it "should create a Thrift::UNIXSocket to wrap accepted sockets" do
-      handle = double("UNIXServer")
-      expect(UNIXServer).to receive(:new).with(@path).and_return(handle)
-      @socket.listen
-      sock = double("sock")
-      expect(handle).to receive(:accept).and_return(sock)
-      trans = double("UNIXSocket")
-      expect(Thrift::UNIXSocket).to receive(:new).and_return(trans)
-      expect(trans).to receive(:handle=).with(sock)
-      expect(@socket.accept).to eq(trans)
-    end
-
-    it "should close the handle when closed" do
-      handle = double("UNIXServer", :closed? => false)
-      expect(UNIXServer).to receive(:new).with(@path).and_return(handle)
-      @socket.listen
-      expect(handle).to receive(:close)
-      allow(File).to receive(:delete)
-      @socket.close
-    end
-
-    it "should delete the socket when closed" do
-      handle = double("UNIXServer", :closed? => false)
-      expect(UNIXServer).to receive(:new).with(@path).and_return(handle)
-      @socket.listen
-      allow(handle).to receive(:close)
-      expect(File).to receive(:delete).with(@path)
-      @socket.close
-    end
-
-    it "should return nil when accepting if there is no handle" do
-      expect(@socket.accept).to be_nil
-    end
-
-    it "should return true for closed? when appropriate" do
-      handle = double("UNIXServer", :closed? => false)
-      allow(UNIXServer).to receive(:new).and_return(handle)
-      allow(File).to receive(:delete)
-      @socket.listen
-      expect(@socket).not_to be_closed
-      allow(handle).to receive(:close)
-      @socket.close
-      expect(@socket).to be_closed
-      @socket.listen
-      expect(@socket).not_to be_closed
-      allow(handle).to receive(:closed?).and_return(true)
-      expect(@socket).to be_closed
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@socket.to_s).to eq("domain(#{@path})")
-    end
-  end
-end