thrift 0.22.0 → 0.23.0

data/spec/bytes_spec.rb

@@ -21,140 +21,79 @@
 require 'spec_helper'
 
 describe Thrift::Bytes do
-  if RUBY_VERSION >= '1.9'
-    describe '.empty_byte_buffer' do
-      it 'should create an empty buffer' do
-        b = Thrift::Bytes.empty_byte_buffer
-        expect(b.length).to eq(0)
-        expect(b.encoding).to eq(Encoding::BINARY)
-      end
-
-      it 'should create an empty buffer of given size' do
-        b = Thrift::Bytes.empty_byte_buffer 2
-        expect(b.length).to eq(2)
-        expect(b.getbyte(0)).to eq(0)
-        expect(b.getbyte(1)).to eq(0)
-        expect(b.encoding).to eq(Encoding::BINARY)
-      end
-    end
-
-    describe '.force_binary_encoding' do
-      it 'should change encoding' do
-        e = 'STRING'.encode('UTF-8')
-        expect(e.encoding).not_to eq(Encoding::BINARY)
-        a = Thrift::Bytes.force_binary_encoding e
-        expect(a.encoding).to eq(Encoding::BINARY)
-      end
-    end
-
-    describe '.get_string_byte' do
-      it 'should get the byte at index' do
-        s = "\x41\x42"
-        expect(Thrift::Bytes.get_string_byte(s, 0)).to eq(0x41)
-        expect(Thrift::Bytes.get_string_byte(s, 1)).to eq(0x42)
-      end
+  describe '.empty_byte_buffer' do
+    it 'should create an empty buffer' do
+      b = Thrift::Bytes.empty_byte_buffer
+      expect(b.length).to eq(0)
+      expect(b.encoding).to eq(Encoding::BINARY)
     end
 
-    describe '.set_string_byte' do
-      it 'should set byte value at index' do
-        s = "\x41\x42"
-        Thrift::Bytes.set_string_byte(s, 0, 0x43)
-        expect(s.getbyte(0)).to eq(0x43)
-        expect(s).to eq('CB')
-      end
+    it 'should create an empty buffer of given size' do
+      b = Thrift::Bytes.empty_byte_buffer 2
+      expect(b.length).to eq(2)
+      expect(b.getbyte(0)).to eq(0)
+      expect(b.getbyte(1)).to eq(0)
+      expect(b.encoding).to eq(Encoding::BINARY)
     end
+  end
 
-    describe '.convert_to_utf8_byte_buffer' do
-      it 'should convert UTF-8 String to byte buffer' do
-        e = "\u20AC".encode('UTF-8') # a string with euro sign character U+20AC
-        expect(e.length).to eq(1)
-
-        a = Thrift::Bytes.convert_to_utf8_byte_buffer e
-        expect(a.encoding).to eq(Encoding::BINARY)
-        expect(a.length).to eq(3)
-        expect(a.unpack('C*')).to eq([0xE2, 0x82, 0xAC])
-      end
-
-      it 'should convert ISO-8859-15 String to UTF-8 byte buffer' do
-        # Assumptions
-        e = "\u20AC".encode('ISO-8859-15') # a string with euro sign character U+20AC, then converted to ISO-8859-15
-        expect(e.length).to eq(1)
-        expect(e.unpack('C*')).to eq([0xA4]) # euro sign is a different code point in ISO-8859-15
-
-        a = Thrift::Bytes.convert_to_utf8_byte_buffer e
-        expect(a.encoding).to eq(Encoding::BINARY)
-        expect(a.length).to eq(3)
-        expect(a.unpack('C*')).to eq([0xE2, 0x82, 0xAC])
-      end
+  describe '.force_binary_encoding' do
+    it 'should change encoding' do
+      e = 'STRING'.encode('UTF-8')
+      expect(e.encoding).not_to eq(Encoding::BINARY)
+      a = Thrift::Bytes.force_binary_encoding e
+      expect(a.encoding).to eq(Encoding::BINARY)
     end
+  end
 
-    describe '.convert_to_string' do
-      it 'should convert UTF-8 byte buffer to a UTF-8 String' do
-        e = [0xE2, 0x82, 0xAC].pack("C*")
-        expect(e.encoding).to eq(Encoding::BINARY)
-        a = Thrift::Bytes.convert_to_string e
-        expect(a.encoding).to eq(Encoding::UTF_8)
-        expect(a).to eq("\u20AC")
-      end
+  describe '.get_string_byte' do
+    it 'should get the byte at index' do
+      s = "\x41\x42"
+      expect(Thrift::Bytes.get_string_byte(s, 0)).to eq(0x41)
+      expect(Thrift::Bytes.get_string_byte(s, 1)).to eq(0x42)
     end
+  end
 
-  else # RUBY_VERSION
-    describe '.empty_byte_buffer' do
-      it 'should create an empty buffer' do
-        b = Thrift::Bytes.empty_byte_buffer
-        expect(b.length).to eq(0)
-      end
-
-      it 'should create an empty buffer of given size' do
-        b = Thrift::Bytes.empty_byte_buffer 2
-        expect(b.length).to eq(2)
-        expect(b[0]).to eq(0)
-        expect(b[1]).to eq(0)
-      end
+  describe '.set_string_byte' do
+    it 'should set byte value at index' do
+      s = "\x41\x42"
+      Thrift::Bytes.set_string_byte(s, 0, 0x43)
+      expect(s.getbyte(0)).to eq(0x43)
+      expect(s).to eq('CB')
     end
+  end
 
-    describe '.force_binary_encoding' do
-      it 'should be a no-op' do
-        e = 'STRING'
-        a = Thrift::Bytes.force_binary_encoding e
-        expect(a).to eq(e)
-        expect(a).to be(e)
-      end
-    end
+  describe '.convert_to_utf8_byte_buffer' do
+    it 'should convert UTF-8 String to byte buffer' do
+      e = "\u20AC".encode('UTF-8') # a string with euro sign character U+20AC
+      expect(e.length).to eq(1)
 
-    describe '.get_string_byte' do
-      it 'should get the byte at index' do
-        s = "\x41\x42"
-        expect(Thrift::Bytes.get_string_byte(s, 0)).to eq(0x41)
-        expect(Thrift::Bytes.get_string_byte(s, 1)).to eq(0x42)
-      end
+      a = Thrift::Bytes.convert_to_utf8_byte_buffer e
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a.length).to eq(3)
+      expect(a.unpack('C*')).to eq([0xE2, 0x82, 0xAC])
     end
 
-    describe '.set_string_byte' do
-      it 'should set byte value at index' do
-        s = "\x41\x42"
-        Thrift::Bytes.set_string_byte(s, 0, 0x43)
-        expect(s[0]).to eq(0x43)
-        expect(s).to eq('CB')
-      end
-    end
+    it 'should convert ISO-8859-15 String to UTF-8 byte buffer' do
+      # Assumptions
+      e = "\u20AC".encode('ISO-8859-15') # a string with euro sign character U+20AC, then converted to ISO-8859-15
+      expect(e.length).to eq(1)
+      expect(e.unpack('C*')).to eq([0xA4]) # euro sign is a different code point in ISO-8859-15
 
-    describe '.convert_to_utf8_byte_buffer' do
-      it 'should be a no-op' do
-        e = 'STRING'
-        a = Thrift::Bytes.convert_to_utf8_byte_buffer e
-        expect(a).to eq(e)
-        expect(a).to be(e)
-      end
+      a = Thrift::Bytes.convert_to_utf8_byte_buffer e
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a.length).to eq(3)
+      expect(a.unpack('C*')).to eq([0xE2, 0x82, 0xAC])
     end
+  end
 
-    describe '.convert_to_string' do
-      it 'should be a no-op' do
-        e = 'STRING'
-        a = Thrift::Bytes.convert_to_string e
-        expect(a).to eq(e)
-        expect(a).to be(e)
-      end
+  describe '.convert_to_string' do
+    it 'should convert UTF-8 byte buffer to a UTF-8 String' do
+      e = [0xE2, 0x82, 0xAC].pack("C*")
+      expect(e.encoding).to eq(Encoding::BINARY)
+      a = Thrift::Bytes.convert_to_string e
+      expect(a.encoding).to eq(Encoding::UTF_8)
+      expect(a).to eq("\u20AC")
     end
   end
 end

data/spec/client_spec.rb

@@ -20,11 +20,15 @@
 require 'spec_helper'
 
 describe 'Client' do
-
   class ClientSpec
     include Thrift::Client
   end
 
+  class EmptyArgs
+    def write(_prot)
+    end
+  end
+
   before(:each) do
     @prot = double("MockProtocol")
     @client = ClientSpec.new(@prot)
@@ -53,15 +57,34 @@ describe 'Client' do
     end
 
     it "should increment the sequence id when sending messages" do
-      pending "it seems sequence ids are completely ignored right now"
-      @prot.expect(:write_message_begin).with('testMessage',  Thrift::MessageTypes::CALL, 0).ordered
-      @prot.expect(:write_message_begin).with('testMessage2', Thrift::MessageTypes::CALL, 1).ordered
-      @prot.expect(:write_message_begin).with('testMessage3', Thrift::MessageTypes::CALL, 2).ordered
-      @prot.stub!(:write_message_end)
-      @prot.stub!(:trans).and_return double("trans").as_null_object
-      @client.send_message('testMessage', double("args class").as_null_object)
-      @client.send_message('testMessage2', double("args class").as_null_object)
-      @client.send_message('testMessage3', double("args class").as_null_object)
+      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::CALL, 0).ordered
+      expect(@prot).to receive(:write_message_begin).with('testMessage2', Thrift::MessageTypes::CALL, 1).ordered
+      expect(@prot).to receive(:write_message_begin).with('testMessage3', Thrift::MessageTypes::CALL, 2).ordered
+      allow(@prot).to receive(:write_message_end)
+      allow(@prot).to receive(:trans).and_return(double("trans", :flush => nil))
+
+      args_class = double("ArgsClass", :new => EmptyArgs.new)
+      @client.send_message('testMessage', args_class)
+      @client.send_message('testMessage2', args_class)
+      @client.send_message('testMessage3', args_class)
+    end
+
+    it "should keep pending reply sequence ids in FIFO order" do
+      expect(@prot).to receive(:write_message_begin).with('first', Thrift::MessageTypes::CALL, 0).ordered
+      expect(@prot).to receive(:write_message_begin).with('second', Thrift::MessageTypes::CALL, 1).ordered
+      allow(@prot).to receive(:write_message_end)
+      allow(@prot).to receive(:trans).and_return(double("trans", :flush => nil))
+
+      args_class = double("ArgsClass", :new => EmptyArgs.new)
+      @client.send_message('first', args_class)
+      @client.send_message('second', args_class)
+
+      expect {
+        @client.validate_message_begin('first', Thrift::MessageTypes::REPLY, 0, 'first')
+      }.not_to raise_error
+      expect {
+        @client.validate_message_begin('second', Thrift::MessageTypes::REPLY, 1, 'second')
+      }.not_to raise_error
     end
 
     it "should receive a test message" do
@@ -73,16 +96,59 @@ describe 'Client' do
       @client.receive_message(double("MockClass", :new => mock_klass))
     end
 
-    it "should handle received exceptions" do
-      expect(@prot).to receive(:read_message_begin).and_return [nil, Thrift::MessageTypes::EXCEPTION, 0]
+    it "should raise BAD_SEQUENCE_ID for mismatched replies" do
+      @client.instance_variable_set(:@pending_seqids, [0])
+
+      expect {
+        @client.validate_message_begin('testMessage', Thrift::MessageTypes::REPLY, 1, 'testMessage')
+      }.to raise_error(Thrift::ApplicationException) { |error|
+        expect(error.type).to eq(Thrift::ApplicationException::BAD_SEQUENCE_ID)
+      }
+    end
+
+    it "should raise WRONG_METHOD_NAME for unexpected replies" do
+      @client.instance_variable_set(:@pending_seqids, [0])
+
+      expect {
+        @client.validate_message_begin('otherMessage', Thrift::MessageTypes::REPLY, 0, 'testMessage')
+      }.to raise_error(Thrift::ApplicationException) { |error|
+        expect(error.type).to eq(Thrift::ApplicationException::WRONG_METHOD_NAME)
+      }
+    end
+
+    it "should raise INVALID_MESSAGE_TYPE for non-reply messages" do
+      @client.instance_variable_set(:@pending_seqids, [0])
+
+      expect {
+        @client.validate_message_begin('testMessage', Thrift::MessageTypes::CALL, 0, 'testMessage')
+      }.to raise_error(Thrift::ApplicationException) { |error|
+        expect(error.type).to eq(Thrift::ApplicationException::INVALID_MESSAGE_TYPE)
+      }
+    end
+
+    it "should raise received application exceptions" do
       expect(@prot).to receive(:read_message_end)
-      expect(Thrift::ApplicationException).to receive(:new) do
-        StandardError.new.tap do |mock_exc|
-          expect(mock_exc).to receive(:read).with(@prot)
-        end
-      end
-      fname, mtype, sqeid = @client.receive_message_begin()
-      expect { @client.handle_exception(mtype) }.to raise_error(StandardError)
+      server_exception = Thrift::ApplicationException.new(Thrift::ApplicationException::UNKNOWN, "boom")
+      expect(server_exception).to receive(:read).with(@prot)
+      expect(Thrift::ApplicationException).to receive(:new).and_return(server_exception)
+      @client.instance_variable_set(:@pending_seqids, [0])
+
+      expect {
+        @client.validate_message_begin('testMessage', Thrift::MessageTypes::EXCEPTION, 0, 'testMessage')
+      }.to raise_error(Thrift::ApplicationException, "boom")
+      expect(@client.instance_variable_get(:@pending_seqids)).to be_empty
+    end
+
+    it "should roll sequence ids across the signed int32 boundary" do
+      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::CALL, Thrift::Client::MAX_SEQUENCE_ID).ordered
+      expect(@prot).to receive(:write_message_begin).with('testMessage2', Thrift::MessageTypes::CALL, Thrift::Client::MIN_SEQUENCE_ID).ordered
+      allow(@prot).to receive(:write_message_end)
+      allow(@prot).to receive(:trans).and_return(double("trans", :flush => nil))
+
+      @client.instance_variable_set(:@seqid, Thrift::Client::MAX_SEQUENCE_ID)
+      args_class = double("ArgsClass", :new => EmptyArgs.new)
+      @client.send_message('testMessage', args_class)
+      @client.send_message('testMessage2', args_class)
     end
 
     it "should close the transport if an error occurs while sending a message" do

data/spec/compact_protocol_spec.rb

@@ -23,22 +23,22 @@ require '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,
+    :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", "unicode characters: \u20AC \u20AD", "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))
@@ -46,7 +46,7 @@ describe Thrift::CompactProtocol do
       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
@@ -71,6 +71,30 @@ describe Thrift::CompactProtocol do
     end
   end
 
+  it "should write a uuid" do
+    trans = Thrift::MemoryBufferTransport.new
+    proto = Thrift::CompactProtocol.new(trans)
+
+    proto.write_uuid("00112233-4455-6677-8899-aabbccddeeff")
+    a = trans.read(trans.available)
+    expect(a.unpack('C*')).to eq([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff])
+  end
+
+  it "should read a uuid" do
+    trans = Thrift::MemoryBufferTransport.new
+    proto = Thrift::CompactProtocol.new(trans)
+
+    trans.write([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff].pack('C*'))
+    uuid = proto.read_uuid
+    expect(uuid).to eq("00112233-4455-6677-8899-aabbccddeeff")
+  end
+
+  it "should error gracefully when trying to write an invalid uuid" do
+    trans = Thrift::MemoryBufferTransport.new
+    proto = Thrift::CompactProtocol.new(trans)
+    expect { proto.write_uuid("invalid") }.to raise_error(Thrift::ProtocolException)
+  end
+
   it "should encode and decode a monster struct correctly" do
     trans = Thrift::MemoryBufferTransport.new
     proto = Thrift::CompactProtocol.new(trans)
@@ -80,7 +104,7 @@ describe Thrift::CompactProtocol do
     struct.write(proto)
 
     struct2 = Thrift::Test::CompactProtoTestStruct.new
-    struct2.read(proto)    
+    struct2.read(proto)
     expect(struct2).to eq(struct)
   end
 
@@ -99,13 +123,27 @@ describe Thrift::CompactProtocol do
     processor.process(client_out_proto, client_in_proto)
     expect(client.recv_Janky).to eq(2)
   end
-  
+
+  it "should round-trip wrapped negative seqids in message headers" do
+    trans = Thrift::MemoryBufferTransport.new
+    writer = Thrift::CompactProtocol.new(trans)
+
+    writer.write_message_begin("test", Thrift::MessageTypes::CALL, -2147483648)
+    writer.write_message_end
+
+    reader = Thrift::CompactProtocol.new(trans)
+    name, type, seqid = reader.read_message_begin
+    expect(name).to eq("test")
+    expect(type).to eq(Thrift::MessageTypes::CALL)
+    expect(seqid).to eq(-2147483648)
+  end
+
   it "should deal with fields following fields that have non-delta ids" do
     brcp = Thrift::Test::BreaksRubyCompactProtocol.new(
-      :field1 => "blah", 
+      :field1 => "blah",
       :field2 => Thrift::Test::BigFieldIdStruct.new(
-        :field1 => "string1", 
-        :field2 => "string2"), 
+        :field1 => "string1",
+        :field2 => "string2"),
       :field3 => 3)
     ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new)
     bytes = ser.serialize(brcp)
@@ -115,7 +153,7 @@ describe Thrift::CompactProtocol do
     deser.deserialize(brcp2, bytes)
     expect(brcp2).to eq(brcp)
   end
-  
+
   it "should deserialize an empty map to an empty hash" do
     struct = Thrift::Test::SingleMapTestStruct.new(:i32_map => {})
     ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new)
@@ -126,22 +164,22 @@ describe Thrift::CompactProtocol do
     deser.deserialize(struct2, bytes)
     expect(struct).to eq(struct2)
   end
-  
+
   it "should provide a reasonable to_s" do
     trans = Thrift::MemoryBufferTransport.new
     expect(Thrift::CompactProtocol.new(trans).to_s).to eq("compact(memory)")
   end
-  
+
   class JankyHandler
     def Janky(i32arg)
       i32arg * 2
     end
   end
-  
+
   def writer(sym)
     "write_#{sym.to_s}"
   end
-  
+
   def reader(sym)
     "read_#{sym.to_s}"
   end

data/spec/constants_demo_spec.rb

@@ -0,0 +1,101 @@
+# 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 'spec_helper'
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb/constants_demo])
+require 'constants_demo_constants'
+
+describe 'ConstantsDemo' do
+  it 'should have correct integer constants' do
+    expect(ConstantsDemo::MyInt).to eq(3)
+    expect(ConstantsDemo::Hex_const).to eq(0x0001F)
+    expect(ConstantsDemo::Negative_hex_constant).to eq(-0x0001F)
+    expect(ConstantsDemo::GEN_ME).to eq(-3523553)
+  end
+
+  it 'should have correct double constants' do
+    expect(ConstantsDemo::GEn_DUB).to eq(325.532)
+    expect(ConstantsDemo::GEn_DU).to eq(85.2355)
+    expect(ConstantsDemo::E10).to eq(1e+10)
+    expect(ConstantsDemo::E11).to eq(-1e+10)
+  end
+
+  it 'should have correct string constants' do
+    expect(ConstantsDemo::GEN_STRING).to eq("asldkjasfd")
+  end
+
+  it 'should have correct uuid constants' do
+    expect(ConstantsDemo::GEN_UUID).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+    expect(ConstantsDemo::GEN_GUID).to eq("00112233-4455-6677-8899-aaBBccDDeeFF")
+    expect(ConstantsDemo::MY_UUID).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+    expect(ConstantsDemo::MY_GUID).to eq("00112233-4455-6677-8899-aaBBccDDeeFF")
+  end
+
+  it 'should have correct list constants' do
+    expect(ConstantsDemo::GEN_LIST).to be_a(Array)
+    expect(ConstantsDemo::GEN_LIST).to eq([235235, 23598352, 3253523])
+  end
+
+  it 'should have correct map constants' do
+    expect(ConstantsDemo::GEN_MAP).to be_a(Hash)
+    expect(ConstantsDemo::GEN_MAP[35532]).to eq(233)
+    expect(ConstantsDemo::GEN_MAP[43523]).to eq(853)
+
+    expect(ConstantsDemo::GEN_MAP2).to be_a(Hash)
+    expect(ConstantsDemo::GEN_MAP2["hello"]).to eq(233)
+    expect(ConstantsDemo::GEN_MAP2["lkj98d"]).to eq(853)
+    expect(ConstantsDemo::GEN_MAP2['lkjsdf']).to eq(98325)
+
+    expect(ConstantsDemo::GEN_MAPMAP).to be_a(Hash)
+    expect(ConstantsDemo::GEN_MAPMAP[235]).to be_a(Hash)
+    expect(ConstantsDemo::GEN_MAPMAP[235][532]).to eq(53255)
+    expect(ConstantsDemo::GEN_MAPMAP[235][235]).to eq(235)
+  end
+
+  it 'should have correct set constants' do
+    expect(ConstantsDemo::GEN_SET).to be_a(Set)
+    expect(ConstantsDemo::GEN_SET.size).to eq(2)
+    expect(ConstantsDemo::GEN_SET.include?(235)).to be true # added twice, but this is a set
+    expect(ConstantsDemo::GEN_SET.include?(53235)).to be true
+
+    expect(ConstantsDemo::GUID_SET).to be_a(Set)
+    expect(ConstantsDemo::GUID_SET.size).to eq(2)
+    expect(ConstantsDemo::GUID_SET.include?("00112233-4455-6677-8899-aaBBccDDeeFF")).to be true
+    expect(ConstantsDemo::GUID_SET.include?("00000000-4444-CCCC-ffff-0123456789ab")).to be true
+  end
+
+  it 'should have correct struct constants' do
+    expect(ConstantsDemo::GEN_THING).to be_a(Thrift::Struct)
+    expect(ConstantsDemo::GEN_THING.hello).to eq(325)
+    expect(ConstantsDemo::GEN_THING.goodbye).to eq(325352)
+    expect(ConstantsDemo::GEN_THING.id).to eq("00112233-4455-6677-8899-aaBBccDDeeFF")
+    expect(ConstantsDemo::GEN_THING.my_id).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+    expect(ConstantsDemo::GEN_THING.my_optional_id).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+
+    expect(ConstantsDemo::GEN_WHAT).to be_a(Hash)
+    expect(ConstantsDemo::GEN_WHAT[35]).to be_a(Thrift::Struct)
+    expect(ConstantsDemo::GEN_WHAT[35].hello).to eq(325)
+    expect(ConstantsDemo::GEN_WHAT[35].goodbye).to eq(325352)
+    expect(ConstantsDemo::GEN_WHAT[35].id).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+    expect(ConstantsDemo::GEN_WHAT[35].my_id).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+    expect(ConstantsDemo::GEN_WHAT[35].my_optional_id).to eq("00000000-4444-CCCC-ffff-0123456789ab")
+  end
+end

data/spec/exception_spec.rb

@@ -20,7 +20,6 @@
 require 'spec_helper'
 
 describe 'Exception' do
-
   describe Thrift::Exception do
     it "should have an accessible message" do
       e = Thrift::Exception.new("test message")