protobuffy 3.6.0 → 4.0.0

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/field_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'protobuf/field'
+require PROTOS_PATH.join('resource.pb')
 
-describe ::Protobuf::Field do
+RSpec.describe ::Protobuf::Field do
 
   describe '.build' do
     pending
@@ -148,7 +149,6 @@ describe ::Protobuf::Field do
       end
     end
 
-
     context 'when type is a string field class or symbol' do
       it 'returns that class' do
         expected_field = ::Protobuf::Field::StringField
@@ -159,7 +159,6 @@ describe ::Protobuf::Field do
       end
     end
 
-
     context 'when type is a bytes field class or symbol' do
       it 'returns that class' do
         expected_field = ::Protobuf::Field::BytesField
@@ -170,7 +169,6 @@ describe ::Protobuf::Field do
       end
     end
 
-
     context 'when type is a bool field class or symbol' do
       it 'returns that class' do
         expected_field = ::Protobuf::Field::BoolField
@@ -183,9 +181,9 @@ describe ::Protobuf::Field do
 
     context 'when type is not mapped' do
       it 'raises an ArgumentError' do
-        expect {
+        expect do
           subject.field_class("boom")
-        }.to raise_error
+        end.to raise_error(ArgumentError)
       end
     end
 

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

@@ -3,15 +3,15 @@ require 'spec_helper'
 require 'protobuf/code_generator'
 require 'protobuf/generators/base'
 
-describe ::Protobuf::Generators::Base do
+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') }
-    subject { described_class.new(descriptor, 0, :namespace => [ :foo, :bar ]) }
-    its(:type_namespace) { should eq [ :foo, :bar, 'Baz' ] }
-    its(:fully_qualified_type_namespace) { should eq '.foo.bar.Baz' }
+    subject { described_class.new(descriptor, 0, :namespace => [:foo, :bar]) }
+    specify { expect(subject.type_namespace).to eq([:foo, :bar, 'Baz']) }
+    specify { expect(subject.fully_qualified_type_namespace).to eq('.foo.bar.Baz') }
   end
 
   describe '#run_once' do
@@ -67,21 +67,88 @@ describe ::Protobuf::Generators::Base do
   describe '#validate_tags' do
     context 'when tags are duplicated' do
       it 'fails with a GeneratorFatalError' do
-        ::Protobuf::CodeGenerator.should_receive(:fatal)
-                                  .with(/FooBar object has duplicate tags\. Expected 3 tags, but got 4/)
-
-        described_class.validate_tags("FooBar", [1,2,2,3])
+        expect(::Protobuf::CodeGenerator).to receive(:fatal).with(/FooBar object has duplicate tags\. Expected 3 tags, but got 4/)
+        described_class.validate_tags("FooBar", [1, 2, 2, 3])
       end
     end
 
     context 'when tags are missing in the range' do
       it 'prints a warning' do
-        ::Protobuf::CodeGenerator.should_receive(:warn)
-                                  .with(/FooBar object should have 5 tags \(1\.\.5\), but found 4 tags/)
-        described_class.validate_tags("FooBar", [1,2,4,5])
+        allow(ENV).to receive(:key?).and_call_original
+        allow(ENV).to receive(:key?).with("PB_NO_TAG_WARNINGS").and_return(false)
+        expect(::Protobuf::CodeGenerator).to receive(:print_tag_warning_suppress)
+        expect(::Protobuf::CodeGenerator).to receive(:warn).with(/FooBar object should have 5 tags \(1\.\.5\), but found 4 tags/)
+        described_class.validate_tags("FooBar", [1, 2, 4, 5])
       end
     end
   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

@@ -2,67 +2,81 @@ require 'spec_helper'
 
 require 'protobuf/generators/enum_generator'
 
-describe ::Protobuf::Generators::EnumGenerator do
+RSpec.describe ::Protobuf::Generators::EnumGenerator do
 
-  let(:values) {
+  let(:values) do
     [
       { :name => 'FOO', :number => 1 },
       { :name => 'BAR', :number => 2 },
-      { :name => 'BAZ', :number => 3 }
+      { :name => 'BAZ', :number => 3 },
     ]
-  }
+  end
   let(:options) { nil }
-  let(:enum_fields) { { :name => 'TestEnum',
-                        :value => values,
-                        :options => options } }
+  let(:enum_fields) do
+    {
+      :name => 'TestEnum',
+      :value => values,
+      :options => options,
+    }
+  end
 
   let(:enum) { ::Google::Protobuf::EnumDescriptorProto.new(enum_fields) }
 
   subject { described_class.new(enum) }
 
   describe '#compile' do
-    let(:compiled) {
-      %q{class TestEnum < ::Protobuf::Enum
+    let(:compiled) do
+      <<-RUBY
+class TestEnum < ::Protobuf::Enum
   define :FOO, 1
   define :BAR, 2
   define :BAZ, 3
 end
 
-}
-    }
+      RUBY
+    end
 
-    it 'compiles the enum and it\'s field values' do
+    it 'compiles the enum and its field values' do
       subject.compile
-      subject.to_s.should eq(compiled)
+      expect(subject.to_s).to eq(compiled)
     end
 
     context 'when allow_alias option is set' do
-      let(:compiled) {
-        %q{class TestEnum < ::Protobuf::Enum
-  set_option :allow_alias
+      let(:compiled) do
+        <<-RUBY
+class TestEnum < ::Protobuf::Enum
+  set_option :allow_alias, true
 
   define :FOO, 1
   define :BAR, 2
   define :BAZ, 3
 end
 
-}
-    }
+        RUBY
+      end
 
       let(:options) { { :allow_alias => true } }
 
       it 'sets the allow_alias option' do
         subject.compile
-        subject.to_s.should eq(compiled)
+        expect(subject.to_s).to eq(compiled)
       end
     end
   end
 
   describe '#build_value' do
     it 'returns a string identifying the given enum value' do
-      subject.build_value(enum.value.first).should eq("define :FOO, 1")
+      expect(subject.build_value(enum.value.first)).to eq("define :FOO, 1")
+    end
+
+    context 'with PB_UPCASE_ENUMS set' do
+      before { allow(ENV).to receive(:key?).with('PB_UPCASE_ENUMS').and_return(true) }
+      let(:values) { [{ :name => 'boom', :number => 1 }] }
+
+      it 'returns a string with the given enum name in ALL CAPS' do
+        expect(subject.build_value(enum.value.first)).to eq("define :BOOM, 1")
+      end
     end
   end
 
 end
-

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

@@ -3,41 +3,40 @@ require 'spec_helper'
 require 'protobuf/code_generator'
 require 'protobuf/generators/extension_generator'
 
-describe ::Protobuf::Generators::ExtensionGenerator do
+RSpec.describe ::Protobuf::Generators::ExtensionGenerator do
 
-  let(:field_descriptors) {
+  let(:field_descriptors) do
     [
       double('field descriptor 1', :to_s => "  field 1\n"),
       double('field descriptor 2', :to_s => "  field 2\n"),
-      double('field descriptor 3', :to_s => "  field 3\n")
+      double('field descriptor 3', :to_s => "  field 3\n"),
     ]
-  }
+  end
   let(:message_type) { 'FooBar' }
 
   before do
-    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[0], 1).and_return(field_descriptors[0])
-    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[1], 1).and_return(field_descriptors[1])
-    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[2], 1).and_return(field_descriptors[2])
+    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])
   end
 
   subject { described_class.new(message_type, field_descriptors, 0) }
 
   describe '#compile' do
-    let(:compiled) {
-      %q{class FooBar < ::Protobuf::Message
+    let(:compiled) do
+      'class FooBar < ::Protobuf::Message
   field 1
   field 2
   field 3
 end
 
-}
-    }
+'
+    end
 
     it 'compiles the a class with the extension fields' do
       subject.compile
-      subject.to_s.should eq(compiled)
+      expect(subject.to_s).to eq(compiled)
     end
   end
 
 end
-

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'protobuf/generators/field_generator'
 
-describe ::Protobuf::Generators::FieldGenerator do
+RSpec.describe ::Protobuf::Generators::FieldGenerator do
 
   let(:label_enum) { :LABEL_OPTIONAL }
   let(:name) { 'foo_bar' }
@@ -13,47 +13,51 @@ describe ::Protobuf::Generators::FieldGenerator do
   let(:extendee) { nil }
   let(:field_options) { {} }
 
-  let(:field_fields) { { :label => label_enum,
-                         :name => name,
-                         :number => number,
-                         :type => type_enum,
-                         :type_name => type_name,
-                         :default_value => default_value,
-                         :extendee => extendee,
-                         :options => field_options } }
+  let(:field_fields) do
+    {
+      :label => label_enum,
+      :name => name,
+      :number => number,
+      :type => type_enum,
+      :type_name => type_name,
+      :default_value => default_value,
+      :extendee => extendee,
+      :options => field_options,
+    }
+  end
 
   let(:field) { ::Google::Protobuf::FieldDescriptorProto.new(field_fields) }
 
   describe '#compile' do
     subject { described_class.new(field).to_s }
 
-    it { should 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' }
 
-      it { should 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' }
-      it { should 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' }
 
-        it { should 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\"" }
 
-        it { should eq %Q{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
@@ -61,17 +65,17 @@ describe ::Protobuf::Generators::FieldGenerator do
 
         context 'when the default value is "nan"' do
           let(:default_value) { 'nan' }
-          it { should match(/::Float::NAN/) }
+          specify { expect(subject).to match(/::Float::NAN/) }
         end
 
         context 'when the default value is "inf"' do
           let(:default_value) { 'inf' }
-          it { should match(/::Float::INFINITY/) }
+          specify { expect(subject).to match(/::Float::INFINITY/) }
         end
 
         context 'when the default value is "-inf"' do
           let(:default_value) { '-inf' }
-          it { should match(/-::Float::INFINITY/) }
+          specify { expect(subject).to match(/-::Float::INFINITY/) }
         end
       end
     end
@@ -79,21 +83,69 @@ describe ::Protobuf::Generators::FieldGenerator do
     context 'when the field is an extension' do
       let(:extendee) { 'foo.bar.Baz' }
 
-      it { should 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 } }
 
-      it { should 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 deprecated' do
       let(:field_options) { { :deprecated => true } }
 
-      it { should 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
+      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
-