protobuf 3.7.0.pre2 → 3.7.0.pre3

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

@@ -1,9 +1,18 @@
 require 'spec_helper'
 
 RSpec.describe Protobuf::Field::MessageField do
+  let(:inner_message) do
+    Class.new(::Protobuf::Message) do
+      optional :int32, :field, 0
+      optional :int32, :field2, 1
+    end
+  end
+
   let(:field_message) do
     Class.new(::Protobuf::Message) do
       optional :int32, :field, 1
+      repeated :int64, :repeated_field, 2
+      optional InnerMessage, :message_field, 3
     end
   end
 
@@ -14,6 +23,7 @@ RSpec.describe Protobuf::Field::MessageField do
   end
 
   before do
+    stub_const('InnerMessage', inner_message)
     stub_const('FieldMessage', field_message)
     stub_const('Message', message)
   end
@@ -76,4 +86,47 @@ RSpec.describe Protobuf::Field::MessageField do
       end
     end
   end
+
+  describe '#option_set' do
+    let(:message_field) { Message.fields[0] }
+    it 'returns unless yield' do
+      # No Error thrown
+      message_field.__send__(:option_set, nil, nil, nil) { false }
+      expect do
+        message_field.__send__(:option_set, nil, nil, nil) { true }
+      end.to raise_error StandardError
+    end
+
+    it 'sets repeated fields' do
+      repeated = field_message.fields[1]
+      instance = field_message.new
+      expect(instance.repeated_field!).to eq(nil)
+      message_field.__send__(:option_set, instance, repeated, [53]) { true }
+      expect(instance.repeated_field!).to eq([53])
+      message_field.__send__(:option_set, instance, repeated, [54]) { true }
+      expect(instance.repeated_field!).to eq([53, 54])
+    end
+
+    it 'sets optional non-message fields' do
+      optional = field_message.fields[0]
+      instance = field_message.new
+      expect(instance.field!).to eq(nil)
+      message_field.__send__(:option_set, instance, optional, 53) { true }
+      expect(instance.field!).to eq(53)
+      message_field.__send__(:option_set, instance, optional, 52) { true }
+      expect(instance.field!).to eq(52)
+    end
+
+    it 'sets nested inner messages fields one at a time' do
+      inner = field_message.fields[2]
+      inner_val = InnerMessage.new(:field => 21)
+      inner_val2 = InnerMessage.new(:field2 => 9)
+      instance = field_message.new
+      expect(instance.message_field!).to eq(nil)
+      message_field.__send__(:option_set, instance, inner, inner_val) { true }
+      expect(instance.message_field!).to eq(InnerMessage.new(:field => 21))
+      message_field.__send__(:option_set, instance, inner, inner_val2) { true }
+      expect(instance.message_field!).to eq(InnerMessage.new(:field => 21, :field2 => 9))
+    end
+  end
 end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Sfixed32Field do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [-1, 0, 1] }
+  end
+
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Sfixed64Field do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [-1, 0, 1] }
+  end
+
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Sint32Field do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [-1, 0, 1] }
+  end
+
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Sint64Field do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [-1, 0, 1] }
+  end
+
+end

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

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Uint32Field do
+
+  it_behaves_like :packable_field, described_class
+
+end

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

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Uint64Field do
+
+  it_behaves_like :packable_field, described_class
+
+end

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

@@ -5,7 +5,7 @@ require 'protobuf/generators/base'
 
 RSpec.describe ::Protobuf::Generators::Base do
 
-  subject { described_class.new(double) }
+  subject(:generator) { described_class.new(double) }
 
   context 'namespaces' do
     let(:descriptor) { double(:name => 'Baz') }
@@ -83,4 +83,72 @@ RSpec.describe ::Protobuf::Generators::Base do
     end
   end
 
+  describe '#serialize_value' do
+    before do
+      stub_const("MyEnum", Class.new(::Protobuf::Enum) do
+        define :FOO, 1
+        define :BOO, 2
+      end)
+      stub_const("MyMessage1", Class.new(Protobuf::Message) do
+        optional :string, :foo, 1
+      end)
+      stub_const("MyMessage2", Class.new(Protobuf::Message) do
+        optional :string, :foo, 1
+        optional MyMessage1, :bar, 2
+        optional :int32, :boom, 3
+        optional MyEnum, :goat, 4
+        optional :bool, :bam, 5
+        optional :float, :fire, 6
+      end)
+      stub_const("MyMessage3", Class.new(Protobuf::Message) do
+        optional :string, :foo, 1
+        repeated MyMessage2, :bar, 2
+        optional :int32, :boom, 3
+        optional MyEnum, :goat, 4
+        optional :bool, :bam, 5
+        optional :float, :fire, 6
+      end)
+    end
+
+    it 'serializes messages' do
+      output_string = <<-STRING
+        { :foo => "space",
+          :bar => [{
+            :foo => "station",
+            :bar => { :foo => "orbit" },
+            :boom => 123,
+            :goat => ::MyEnum::FOO,
+            :bam => false,
+            :fire => 3.5 }],
+          :boom => 456,
+          :goat => ::MyEnum::BOO,
+          :bam => true, :fire => 1.2 }
+      STRING
+
+      output_string.lstrip!
+      output_string.rstrip!
+      output_string.delete!("\n")
+      output_string.squeeze!(" ")
+      expect(generator.serialize_value(MyMessage3.new(
+                                         :foo => 'space',
+                                         :bar => [MyMessage2.new(
+                                           :foo => 'station',
+                                           :bar => MyMessage1.new(:foo => 'orbit'),
+                                           :boom => 123,
+                                           :goat => MyEnum::FOO,
+                                           :bam => false,
+                                           :fire => 3.5,
+                                         )],
+                                         :boom => 456,
+                                         :goat => MyEnum::BOO,
+                                         :bam => true,
+                                         :fire => 1.2,
+      ))).to eq(output_string)
+    end
+
+    it 'serializes enums' do
+      expect(generator.serialize_value(MyEnum::FOO)).to eq("::MyEnum::FOO")
+      expect(generator.serialize_value(MyEnum::BOO)).to eq("::MyEnum::BOO")
+    end
+  end
 end

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

@@ -45,7 +45,7 @@ end
       let(:compiled) do
         <<-RUBY
 class TestEnum < ::Protobuf::Enum
-  set_option :allow_alias
+  set_option :allow_alias, true
 
   define :FOO, 1
   define :BAR, 2

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

@@ -53,6 +53,15 @@ RSpec.describe ::Protobuf::Generators::FieldGenerator do
         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
+        let(:type_enum) { :TYPE_ENUM }
+        let(:type_name) { '.foo.bar.Baz' }
+        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" }
+      end
+
       context 'when the type is a string' do
         let(:type_enum) { :TYPE_STRING }
         let(:default_value) { "a default \"string\"" }
@@ -97,6 +106,55 @@ RSpec.describe ::Protobuf::Generators::FieldGenerator do
 
       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
+      class ::CustomFieldEnum < ::Protobuf::Enum
+        define :BOOM, 1
+        define :BAM, 2
+      end
+
+      class ::CustomFieldMessage < ::Protobuf::Message
+        optional :string, :foo, 1
+      end
+
+      class ::Google::Protobuf::FieldOptions < ::Protobuf::Message
+        optional :string, :custom_string_option, 22000, :extension => true
+        optional :bool, :custom_bool_option, 22001, :extension => true
+        optional :int32, :custom_int32_option, 22002, :extension => true
+        optional ::CustomFieldEnum, :custom_enum_option, 22003, :extension => true
+        optional ::CustomFieldMessage, :custom_message_option, 22004, :extension => true
+      end
+
+      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" }
+      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" }
+      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" }
+      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" }
+      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" }
+      end
+    end
   end
 
 end

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

@@ -61,5 +61,52 @@ end
 
 EOF
     end
+
+    context 'with extended messages' do
+      let(:descriptor_fields) do
+        base_descriptor_fields.merge(
+          :package => 'test.pkg.file_generator_spec',
+          :extension => [{
+            :name => 'boom',
+            :number => 20_000,
+            :label => Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL,
+            :type => Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING,
+            :extendee => '.google.protobuf.FieldOptions',
+          }],
+        )
+      end
+
+      it 'generates the file contents that include the namespaced extension name' do
+        subject.compile
+        expect(subject.to_s).to eq <<EOF
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+module Test
+  module Pkg
+    module File_generator_spec
+      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
+
+      ##
+      # Extended Message Fields
+      #
+      class ::Google::Protobuf::FieldOptions < ::Protobuf::Message
+        optional :string, :".test.pkg.file_generator_spec.boom", 20000, :extension => true
+      end
+
+    end
+
+  end
+
+end
+
+EOF
+      end
+    end
+
   end
 end

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

@@ -4,10 +4,38 @@ require 'protobuf/generators/service_generator'
 
 RSpec.describe ::Protobuf::Generators::ServiceGenerator do
 
+  class ::CustomMethodEnum < ::Protobuf::Enum
+    define :BOOM, 1
+    define :BAM, 2
+  end
+
+  class ::CustomMethodMessage < ::Protobuf::Message
+    optional :string, :foo, 1
+  end
+
+  class ::Google::Protobuf::MethodOptions < ::Protobuf::Message
+    optional :string, :custom_string_option, 22000, :extension => true
+    optional :bool, :custom_bool_option, 22001, :extension => true
+    optional :int32, :custom_int32_option, 22002, :extension => true
+    optional ::CustomMethodEnum, :custom_enum_option, 22003, :extension => true
+    optional ::CustomMethodMessage, :custom_message_option, 22004, :extension => true
+  end
+
   let(:methods) do
     [
       { :name => 'Search', :input_type => 'FooRequest', :output_type => 'FooResponse' },
-      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' },
+      {
+        :name => 'FooBar',
+        :input_type => '.foo.Request',
+        :output_type => '.bar.Response',
+        :options => {
+          :custom_string_option => 'boom',
+          :custom_bool_option => true,
+          :custom_int32_option => 123,
+          :custom_message_option => CustomMethodMessage.new(:foo => 'bam'),
+          :custom_enum_option => CustomMethodEnum::BAM,
+        },
+      },
     ]
   end
   let(:service_fields) do
@@ -19,37 +47,53 @@ RSpec.describe ::Protobuf::Generators::ServiceGenerator do
 
   let(:service) { ::Google::Protobuf::ServiceDescriptorProto.new(service_fields) }
 
-  subject { described_class.new(service) }
+  subject(:service_generator) { described_class.new(service) }
 
   describe '#compile' do
     let(:compiled) do
-      'class TestService < ::Protobuf::Rpc::Service
+      <<EOF
+class TestService < ::Protobuf::Rpc::Service
   rpc :search, FooRequest, FooResponse
-  rpc :foo_bar, ::Foo::Request, ::Bar::Response
+  rpc :foo_bar, ::Foo::Request, ::Bar::Response do
+    set_option :custom_string_option, "boom"
+    set_option :custom_bool_option, true
+    set_option :custom_int32_option, 123
+    set_option :custom_enum_option, ::CustomMethodEnum::BAM
+    set_option :custom_message_option, { :foo => "bam" }
+  end
 end
 
-'
+EOF
     end
 
-    it 'compiles the service and it\'s rpc methods' do
+    it "compiles the service and it's rpc methods" do
       subject.compile
       expect(subject.to_s).to eq(compiled)
     end
+
+    context 'with PB_USE_RAW_RPC_NAMES in the environemnt' do
+      let(:compiled) do
+        <<EOF
+class TestService < ::Protobuf::Rpc::Service
+  rpc :Search, FooRequest, FooResponse
+  rpc :FooBar, ::Foo::Request, ::Bar::Response do
+    set_option :custom_string_option, "boom"
+    set_option :custom_bool_option, true
+    set_option :custom_int32_option, 123
+    set_option :custom_enum_option, ::CustomMethodEnum::BAM
+    set_option :custom_message_option, { :foo => "bam" }
   end
+end
 
-  describe '#build_method' do
-    it 'returns a string identifying the given method descriptor' do
-      expect(subject.build_method(service.method.first)).to eq("rpc :search, FooRequest, FooResponse")
-    end
+EOF
+      end
 
-    context 'with PB_USE_RAW_RPC_NAMES in the environemnt' do
       before { allow(ENV).to receive(:key?).with('PB_USE_RAW_RPC_NAMES').and_return(true) }
 
       it 'uses the raw RPC name and does not underscore it' do
-        expect(subject.build_method(service.method.first)).to eq("rpc :Search, FooRequest, FooResponse")
-        expect(subject.build_method(service.method.last)).to eq("rpc :FooBar, ::Foo::Request, ::Bar::Response")
+        subject.compile
+        expect(subject.to_s).to eq(compiled)
       end
     end
   end
-
 end

data/spec/lib/protobuf/message_spec.rb

@@ -142,12 +142,12 @@ RSpec.describe Protobuf::Message do
   describe '#initialize' do
     it "defaults to the first value listed in the enum's type definition" do
       test_enum = Test::EnumTestMessage.new
-      expect(test_enum.non_default_enum).to eq(1)
+      expect(test_enum.non_default_enum).to eq(Test::EnumTestType.enums.first)
     end
 
     it "defaults to a a value with a name" do
       test_enum = Test::EnumTestMessage.new
-      expect(test_enum.non_default_enum.name).to eq(:ONE)
+      expect(test_enum.non_default_enum.name).to eq(Test::EnumTestType.enums.first.name)
     end
 
     it "exposes the enum getter raw value through ! method" do

data/spec/lib/protobuf/optionable_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'protobuf/optionable'
 require 'protobuf/field/message_field'
+require PROTOS_PATH.join('resource.pb')
 
 RSpec.describe 'Optionable' do
   describe '.{get,get!}_option' do
@@ -166,4 +167,99 @@ RSpec.describe 'Optionable' do
       end
     end
   end
+
+  describe 'getting options from generated code' do
+    context 'file options' do
+      it 'gets base options' do
+        expect(::Test.get_option!(:cc_generic_services)).to eq(true)
+      end
+
+      it 'gets unset options' do
+        expect(::Test.get_option!(:java_multiple_files)).to eq(nil)
+        expect(::Test.get_option(:java_multiple_files)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(::Test.get_option!(:".test.file_option")).to eq(9876543210)
+      end
+    end
+
+    context 'field options' do
+      subject { ::Test::Resource.fields[0] }
+
+      it 'gets base options' do
+        expect(subject.get_option!(:ctype))
+          .to eq(::Google::Protobuf::FieldOptions::CType::CORD)
+      end
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:lazy)).to eq(nil)
+        expect(subject.get_option(:lazy)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.field_option")).to eq(8765432109)
+      end
+    end
+
+    context 'enum options' do
+      subject { ::Test::StatusType }
+
+      it 'gets base options' do
+        expect(subject.get_option!(:allow_alias)).to eq(true)
+      end
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:deprecated)).to eq(nil)
+        expect(subject.get_option(:deprecated)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.enum_option")).to eq(-789)
+      end
+    end
+
+    context 'message options' do
+      subject { ::Test::Resource }
+
+      it 'gets base options' do
+        expect(subject.get_option!(:map_entry)).to eq(false)
+      end
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:deprecated)).to eq(nil)
+        expect(subject.get_option(:deprecated)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.message_option")).to eq(-56)
+      end
+    end
+
+    context 'service options' do
+      subject { ::Test::ResourceService }
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:deprecated)).to eq(nil)
+        expect(subject.get_option(:deprecated)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.service_option")).to eq(-9876543210)
+      end
+    end
+
+    context 'method options' do
+      subject { ::Test::ResourceService.rpcs[:find] }
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:deprecated)).to eq(nil)
+        expect(subject.get_option(:deprecated)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.method_option")).to eq(2)
+      end
+    end
+  end
 end