protobuf 3.7.5 → 3.8.0.pre1

data/spec/lib/protobuf/field/field_hash_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FieldHash do
+
+  let(:basic_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :field, 1
+    end
+  end
+
+  let(:more_complex_message) do
+    Class.new(BasicMessage) do
+    end
+  end
+
+  let(:some_enum) do
+    Class.new(::Protobuf::Enum) do
+      define :FOO, 1
+      define :BAR, 2
+      define :BAZ, 3
+    end
+  end
+
+  let(:map_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :some_string, 1
+      map :int32, :string, :map_int32_to_string, 2
+      map :string, BasicMessage, :map_string_to_msg, 3
+      map :string, SomeEnum, :map_string_to_enum, 4
+    end
+  end
+
+  before do
+    stub_const('BasicMessage', basic_message)
+    stub_const('MoreComplexMessage', more_complex_message)
+    stub_const('SomeEnum', some_enum)
+    stub_const('SomeMapMessage', map_message)
+  end
+
+  let(:instance) { SomeMapMessage.new }
+
+  %w([]= store).each do |method|
+    describe "##{method}" do
+      context 'when applied to an int32->string field hash' do
+        it 'adds an int -> string entry' do
+          expect(instance.map_int32_to_string).to be_empty
+          instance.map_int32_to_string.send(method, 1, 'string 1')
+          expect(instance.map_int32_to_string).to eq(1 => 'string 1')
+          instance.map_int32_to_string.send(method, 2, 'string 2')
+          expect(instance.map_int32_to_string).to eq(1 => 'string 1', 2 => 'string 2')
+        end
+
+        it 'fails if not adding an int -> string' do
+          expect { instance.map_int32_to_string.send(method, 1, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, 'foo', 100.0) }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, BasicMessage.new, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, 'foo', 'bar') }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, nil, 'foo') }.to raise_error(TypeError)
+          expect { instance.map_int32_to_string.send(method, 1, nil) }.to raise_error(TypeError)
+        end
+      end
+
+      context 'when applied to a string->MessageField field hash' do
+        it 'adds a string -> MessageField entry' do
+          expect(instance.map_string_to_msg).to be_empty
+          basic_msg1 = BasicMessage.new
+          instance.map_string_to_msg.send(method, 'msg1', basic_msg1)
+          expect(instance.map_string_to_msg).to eq('msg1' => basic_msg1)
+          basic_msg2 = BasicMessage.new
+          instance.map_string_to_msg.send(method, 'msg2', basic_msg2)
+          expect(instance.map_string_to_msg).to eq('msg1' => basic_msg1, 'msg2' => basic_msg2)
+        end
+
+        it 'fails if not adding a string -> MessageField entry' do
+          expect { instance.map_string_to_msg.send(method, 1, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, 'foo', SomeEnum::FOO) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, SomeEnum::FOO, BasicMessage.new) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, nil, BasicMessage.new) }.to raise_error(TypeError)
+          expect { instance.map_string_to_msg.send(method, 'foo', nil) }.to raise_error(TypeError)
+        end
+
+        it 'adds a Hash from a MessageField object' do
+          expect(instance.map_string_to_msg).to be_empty
+          basic_msg1 = BasicMessage.new
+          basic_msg1.field = 'my value'
+          instance.map_string_to_msg.send(method, 'foo', basic_msg1.to_hash)
+          expect(instance.map_string_to_msg).to eq('foo' => basic_msg1)
+        end
+
+        it 'does not downcast a MessageField' do
+          expect(instance.map_string_to_msg).to be_empty
+          basic_msg1 = MoreComplexMessage.new
+          instance.map_string_to_msg.send(method, 'foo', basic_msg1)
+          expect(instance.map_string_to_msg).to eq('foo' => basic_msg1)
+          expect(instance.map_string_to_msg['foo']).to be_a(MoreComplexMessage)
+        end
+      end
+
+      context 'when applied to a string->EnumField field hash' do
+        it 'adds a string -> EnumField entry' do
+          expect(instance.map_string_to_enum).to be_empty
+          instance.map_string_to_enum.send(method, 'msg1', SomeEnum::FOO)
+          expect(instance.map_string_to_enum).to eq('msg1' => SomeEnum::FOO)
+          instance.map_string_to_enum.send(method, 'msg2', SomeEnum::BAR)
+          expect(instance.map_string_to_enum).to eq('msg1' => SomeEnum::FOO, 'msg2' => SomeEnum::BAR)
+        end
+
+        it 'fails if not adding a string -> EnumField entry' do
+          expect { instance.map_string_to_enum.send(method, 1, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, nil, 100.0) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 1, nil) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 'foo', BasicMessage.new) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 1, SomeEnum::FOO) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, nil, SomeEnum::FOO) }.to raise_error(TypeError)
+          expect { instance.map_string_to_enum.send(method, 'foo', nil) }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe '#to_hash_value' do
+      context 'when applied to an int32->string field hash' do
+        before do
+          instance.map_int32_to_string[1] = 'string 1'
+          instance.map_int32_to_string[2] = 'string 2'
+        end
+
+        it 'converts properly' do
+          expect(instance.to_hash_value).to eq(:map_int32_to_string => {
+            1 => 'string 1',
+            2 => 'string 2',
+          })
+        end
+      end
+
+      context 'when applied to a string->MessageField field hash' do
+        before do
+          instance.map_string_to_msg['msg1'] = BasicMessage.new(:field => 'string 1')
+          instance.map_string_to_msg['msg2'] = BasicMessage.new(:field => 'string 2')
+        end
+
+        it 'converts properly' do
+          expect(instance.to_hash_value).to eq(:map_string_to_msg => {
+            'msg1' => {
+              :field => 'string 1',
+            },
+            'msg2' => {
+              :field => 'string 2',
+            },
+          })
+        end
+      end
+
+      context 'when applied to a string->EnumField field hash' do
+        before do
+          instance.map_string_to_enum['msg1'] = SomeEnum::FOO
+          instance.map_string_to_enum['msg2'] = SomeEnum::BAR
+        end
+
+        it 'converts properly' do
+          expect(instance.to_hash_value).to eq(:map_string_to_enum => {
+            'msg1' => 1,
+            'msg2' => 2,
+          })
+        end
+      end
+    end
+  end
+end

data/spec/lib/protobuf/generators/extension_generator_spec.rb

@@ -15,9 +15,9 @@ RSpec.describe ::Protobuf::Generators::ExtensionGenerator do
   let(:message_type) { 'FooBar' }
 
   before do
-    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[0], 1).and_return(field_descriptors[0])
-    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[1], 1).and_return(field_descriptors[1])
-    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[2], 1).and_return(field_descriptors[2])
+    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[0], nil, 1).and_return(field_descriptors[0])
+    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[1], nil, 1).and_return(field_descriptors[1])
+    expect(::Protobuf::Generators::FieldGenerator).to receive(:new).with(field_descriptors[2], nil, 1).and_return(field_descriptors[2])
   end
 
   subject { described_class.new(message_type, field_descriptors, 0) }

data/spec/lib/protobuf/generators/field_generator_spec.rb

@@ -25,32 +25,41 @@ RSpec.describe ::Protobuf::Generators::FieldGenerator do
       :options => field_options,
     }
   end
-
   let(:field) { ::Google::Protobuf::FieldDescriptorProto.new(field_fields) }
 
+  let(:nested_types) { [] }
+  let(:owner_fields) do
+    {
+      :name => 'Baz',
+      :field => [field],
+      :nested_type => nested_types,
+    }
+  end
+  let(:owner_msg) { ::Google::Protobuf::DescriptorProto.new(owner_fields) }
+
   describe '#compile' do
-    subject { described_class.new(field).to_s }
+    subject { described_class.new(field, owner_msg, 1).to_s }
 
-    specify { expect(subject).to eq "optional :string, :foo_bar, 3\n" }
+    specify { expect(subject).to eq "  optional :string, :foo_bar, 3\n" }
 
     context 'when the type is another message' do
       let(:type_enum) { :TYPE_MESSAGE }
       let(:type_name) { '.foo.bar.Baz' }
 
-      specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
+      specify { expect(subject).to eq "  optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
     end
 
     context 'when a default value is used' do
       let(:type_enum) { :TYPE_INT32 }
       let(:default_value) { '42' }
-      specify { expect(subject).to eq "optional :int32, :foo_bar, 3, :default => 42\n" }
+      specify { expect(subject).to eq "  optional :int32, :foo_bar, 3, :default => 42\n" }
 
       context 'when type is an enum' do
         let(:type_enum) { :TYPE_ENUM }
         let(:type_name) { '.foo.bar.Baz' }
         let(:default_value) { 'QUUX' }
 
-        specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
+        specify { expect(subject).to eq "  optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
       end
 
       context 'when type is an enum with lowercase default value with PB_UPCASE_ENUMS set' do
@@ -59,14 +68,14 @@ RSpec.describe ::Protobuf::Generators::FieldGenerator do
         let(:default_value) { 'quux' }
         before { allow(ENV).to receive(:key?).with('PB_UPCASE_ENUMS').and_return(true) }
 
-        specify { expect(subject).to eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
+        specify { expect(subject).to eq "  optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
       end
 
       context 'when the type is a string' do
         let(:type_enum) { :TYPE_STRING }
         let(:default_value) { "a default \"string\"" }
 
-        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :default => \"a default \"string\"\"\n" }
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :default => \"a default \"string\"\"\n" }
       end
 
       context 'when float or double field type' do
@@ -92,19 +101,47 @@ RSpec.describe ::Protobuf::Generators::FieldGenerator do
     context 'when the field is an extension' do
       let(:extendee) { 'foo.bar.Baz' }
 
-      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :extension => true\n" }
+      specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :extension => true\n" }
     end
 
     context 'when field is packed' do
       let(:field_options) { { :packed => true } }
 
-      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :packed => true\n" }
+      specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :packed => true\n" }
+    end
+
+    context 'when field is a map' do
+      let(:type_enum) { :TYPE_MESSAGE }
+      let(:type_name) { '.foo.bar.Baz.FooBarEntry' }
+      let(:label_enum) { :LABEL_REPEATED }
+      let(:nested_types) do
+        [::Google::Protobuf::DescriptorProto.new(
+          :name => 'FooBarEntry',
+          :field => [
+            ::Google::Protobuf::FieldDescriptorProto.new(
+              :label => :LABEL_OPTIONAL,
+              :name => 'key',
+              :number => 1,
+              :type => :TYPE_STRING,
+              :type_name => nil),
+            ::Google::Protobuf::FieldDescriptorProto.new(
+              :label => :LABEL_OPTIONAL,
+              :name => 'value',
+              :number => 2,
+              :type => :TYPE_ENUM,
+              :type_name => '.foo.bar.SnafuState'),
+          ],
+          :options => ::Google::Protobuf::MessageOptions.new(:map_entry => true)),
+        ]
+      end
+
+      specify { expect(subject).to eq "  map :string, ::Foo::Bar::SnafuState, :foo_bar, 3\n" }
     end
 
     context 'when field is deprecated' do
       let(:field_options) { { :deprecated => true } }
 
-      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
+      specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :deprecated => true\n" }
     end
 
     context 'when field uses a custom option that is an extension' do
@@ -128,31 +165,31 @@ RSpec.describe ::Protobuf::Generators::FieldGenerator do
       describe 'option has a string value' do
         let(:field_options) { { :custom_string_option => 'boom' } }
 
-        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :custom_string_option => \"boom\"\n" }
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :custom_string_option => \"boom\"\n" }
       end
 
       describe 'option has a bool value' do
         let(:field_options) { { :custom_bool_option => true } }
 
-        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :custom_bool_option => true\n" }
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :custom_bool_option => true\n" }
       end
 
       describe 'option has a int32 value' do
         let(:field_options) { { :custom_int32_option => 123 } }
 
-        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :custom_int32_option => 123\n" }
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :custom_int32_option => 123\n" }
       end
 
       describe 'option has a message value' do
         let(:field_options) { { :custom_message_option => CustomFieldMessage.new(:foo => 'boom') } }
 
-        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :custom_message_option => { :foo => \"boom\" }\n" }
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :custom_message_option => { :foo => \"boom\" }\n" }
       end
 
       describe 'option has a enum value' do
         let(:field_options) { { :custom_enum_option => CustomFieldEnum::BAM } }
 
-        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :custom_enum_option => ::CustomFieldEnum::BAM\n" }
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :custom_enum_option => ::CustomFieldEnum::BAM\n" }
       end
     end
   end

data/spec/lib/protobuf/message_spec.rb

@@ -715,6 +715,43 @@ RSpec.describe Protobuf::Message do
     end
   end
 
+  describe 'map fields' do
+    it 'serializes the same as equivalent non-map-field' do
+      class MessageWithMapField < ::Protobuf::Message
+        map :int32, :string, :map, 1
+      end
+
+      class MessageWithoutMapField < ::Protobuf::Message
+        class MapEntry < ::Protobuf::Message
+          optional :int32, :key, 1
+          optional :string, :value, 2
+        end
+        repeated MapEntry, :map, 1
+      end
+
+      map_msg = MessageWithMapField.new(:map =>
+        {
+          1 => 'one',
+          2 => 'two',
+          3 => 'three',
+          4 => 'four',
+        })
+      mapless_msg = MessageWithoutMapField.new(:map =>
+        [{ :key => 1, :value => 'one' },
+         { :key => 2, :value => 'two' },
+         { :key => 3, :value => 'three' },
+         { :key => 4, :value => 'four' },
+        ])
+
+      map_bytes = map_msg.encode
+      mapless_bytes = mapless_msg.encode
+      expect(map_bytes).to eq(mapless_bytes)
+
+      expect(MessageWithMapField.decode(mapless_bytes)).to eq(map_msg)
+      expect(MessageWithoutMapField.decode(map_bytes)).to eq(mapless_msg)
+    end
+  end
+
   describe '.[]=' do
     context 'clearing fields' do
       it 'clears repeated fields with an empty array' do

data/spec/lib/protobuf/rpc/middleware/request_decoder_spec.rb

@@ -86,7 +86,7 @@ RSpec.describe Protobuf::Rpc::Middleware::RequestDecoder do
       let(:request_wrapper) do
         ::Protobuf::Socketrpc::Request.new(
           :caller => client_host,
-          :service_name => 'Foo',
+          :service_name => 'NonexistantService',
           :method_name => method_name.to_s,
           :request_proto => request,
         )

data/spec/support/protos/map-test.bin

@@ -0,0 +1,157 @@
+
+�!
+map-test.protofoo"�

+Baz2
+looks_like_map
 (2.foo.Baz.LooksLikeMapEntry@
+does_not_look_like_map (2 .foo.Baz.DoesNotLookLikeMapEntry3
+LooksLikeMapEntry
+key
 
(	
+value 
(	:8
5
+DoesNotLookLikeMapEntry
+key
 
(	
+value 
(	"�
+Bar0
+
+
+int32_to_baz (2.foo.Bar.Int32ToBazEntry.
+int64_to_baz (2.foo.Bar.Int64ToBazEntry0
+
+
+
+sint32_to_frobnitz (2.foo.Bar.Sint32ToFrobnitzEntry:
+sint64_to_frobnitz	 (2.foo.Bar.Sint64ToFrobnitzEntry8
+int32_to_frobnitz
+ (2.foo.Bar.Int32ToFrobnitzEntry8
+int64_to_frobnitz (2.foo.Bar.Int64ToFrobnitzEntry:
+uint32_to_frobnitz (2.foo.Bar.Uint32ToFrobnitzEntry:
+uint64_to_frobnitz
 (2.foo.Bar.Uint64ToFrobnitzEntry:
+string_to_frobnitz (2.foo.Bar.StringToFrobnitzEntry6
+sint32_to_string (2.foo.Bar.Sint32ToStringEntry6
+sint64_to_string (2.foo.Bar.Sint64ToStringEntry4
+int32_to_string (2.foo.Bar.Int32ToStringEntry4
+int64_to_string (2.foo.Bar.Int64ToStringEntry6
+uint32_to_string (2.foo.Bar.Uint32ToStringEntry6
+uint64_to_string (2.foo.Bar.Uint64ToStringEntry6
+string_to_string (2.foo.Bar.StringToStringEntry4
+sint32_to_float (2.foo.Bar.Sint32ToFloatEntry4
+sint64_to_float (2.foo.Bar.Sint64ToFloatEntry2
+int32_to_float (2.foo.Bar.Int32ToFloatEntry2
+int64_to_float (2.foo.Bar.Int64ToFloatEntry4
+uint32_to_float (2.foo.Bar.Uint32ToFloatEntry4
+uint64_to_float (2.foo.Bar.Uint64ToFloatEntry4
+string_to_float (2.foo.Bar.StringToFloatEntry6
+sint32_to_double (2.foo.Bar.Sint32ToDoubleEntry6
+sint64_to_double (2.foo.Bar.Sint64ToDoubleEntry4
+int32_to_double (2.foo.Bar.Int32ToDoubleEntry4
+int64_to_double  (2.foo.Bar.Int64ToDoubleEntry6
+uint32_to_double! (2.foo.Bar.Uint32ToDoubleEntry6
+uint64_to_double" (2.foo.Bar.Uint64ToDoubleEntry6
+string_to_double# (2.foo.Bar.StringToDoubleEntry<
+Sint32ToBazEntry
+key
 
(
+value 
(2.foo.Baz:8
<
+Sint64ToBazEntry
+key
 
(
+value 
(2.foo.Baz:8
;
+Int32ToBazEntry
+key
 
(
+value 
(2.foo.Baz:8
;
+Int64ToBazEntry
+key
 
(
+value 
(2.foo.Baz:8
<
+Uint32ToBazEntry
+key
 
(
+value 
(2.foo.Baz:8
<
+Uint64ToBazEntry
+key
 
(
+value 
(2.foo.Baz:8
<
+StringToBazEntry
+key
 
(	
+value 
(2.foo.Baz:8
F
+Sint32ToFrobnitzEntry
+key
 
(
+value 
(2
+Sint64ToFrobnitzEntry
+key
 
(
+value 
(2
+Int32ToFrobnitzEntry
+key
 
(
+value 
(2
+Int64ToFrobnitzEntry
+key
 
(
+value 
(2
+Uint32ToFrobnitzEntry
+key
 
(
+value 
(2
+Uint64ToFrobnitzEntry
+key
 
(
+value 
(2
+StringToFrobnitzEntry
+key
 
(	
+value 
(2
+Sint32ToStringEntry
+key
 
(
+value 
(	:8
5
+Sint64ToStringEntry
+key
 
(
+value 
(	:8
4
+Int32ToStringEntry
+key
 
(
+value 
(	:8
4
+Int64ToStringEntry
+key
 
(
+value 
(	:8
5
+Uint32ToStringEntry
+key
 
(
+value 
(	:8
5
+Uint64ToStringEntry
+key
 
(
+value 
(	:8
5
+StringToStringEntry
+key
 
(	
+value 
(	:8
4
+Sint32ToFloatEntry
+key
 
(
+value 
(:8
4
+Sint64ToFloatEntry
+key
 
(
+value 
(:8
3
+Int32ToFloatEntry
+key
 
(
+value 
(:8
3
+Int64ToFloatEntry
+key
 
(
+value 
(:8
4
+Uint32ToFloatEntry
+key
 
(
+value 
(:8
4
+Uint64ToFloatEntry
+key
 
(
+value 
(:8
4
+StringToFloatEntry
+key
 
(	
+value 
(:8
5
+Sint32ToDoubleEntry
+key
 
(
+value 
(
:8
5
+Sint64ToDoubleEntry
+key
 
(
+value 
(
:8
4
+Int32ToDoubleEntry
+key
 
(
+value 
(
:8
4
+Int64ToDoubleEntry
+key
 
(
+value 
(
:8
5
+Uint32ToDoubleEntry
+key
 
(
+value 
(
:8
5
+Uint64ToDoubleEntry
+key
 
(
+value 
(
:8
5
+StringToDoubleEntry
+key
 
(	
+value 
(
:8
*
+Frobnitz
+FROB

+NITZ