protobuffy 3.6.0 → 4.0.0

data/spec/lib/protobuf/code_generator_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'protobuf/code_generator'
 
-describe ::Protobuf::CodeGenerator do
+RSpec.describe ::Protobuf::CodeGenerator do
 
   # Some constants to shorten things up
   DESCRIPTOR = ::Google::Protobuf
@@ -19,30 +19,58 @@ describe ::Protobuf::CodeGenerator do
     let(:file_generator2) { double('file generator 2', :generate_output_file => output_file2) }
 
     let(:request_bytes) do
-      COMPILER::CodeGeneratorRequest.encode(:proto_file => [ input_file1, input_file2 ])
+      COMPILER::CodeGeneratorRequest.encode(:proto_file => [input_file1, input_file2])
     end
 
     let(:expected_response_bytes) do
-      COMPILER::CodeGeneratorResponse.encode(:file => [ output_file1, output_file2 ])
+      COMPILER::CodeGeneratorResponse.encode(:file => [output_file1, output_file2])
     end
 
     before do
-      ::Protobuf::Generators::FileGenerator.should_receive(:new).with(input_file1).and_return(file_generator1)
-      ::Protobuf::Generators::FileGenerator.should_receive(:new).with(input_file2).and_return(file_generator2)
+      expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file1).and_return(file_generator1)
+      expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file2).and_return(file_generator2)
     end
 
     it 'returns the serialized CodeGeneratorResponse which contains the generated file contents' do
       generator = described_class.new(request_bytes)
-      generator.response_bytes.should eq expected_response_bytes
+      expect(generator.response_bytes).to eq expected_response_bytes
+    end
+  end
+
+  describe '#eval_unknown_extensions' do
+    let(:input_file) do
+      DESCRIPTOR::FileDescriptorProto.new(
+        :name => 'test/boom.proto',
+        :package => 'test.pkg.code_generator_spec',
+        :extension => [{
+          :name => 'boom',
+          :number => 20100,
+          :label => Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL,
+          :type => Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING,
+          :extendee => '.google.protobuf.FieldOptions',
+        }]
+      )
+    end
+    let(:request_bytes) { COMPILER::CodeGeneratorRequest.encode(:proto_file => [input_file]) }
+
+    it 'evals files as they are generated' do
+      described_class.new(request_bytes).eval_unknown_extensions!
+      expect(Google::Protobuf::FieldOptions.extension_fields.map(&:fully_qualified_name)).to include(:'.test.pkg.code_generator_spec.boom')
+      expect(Google::Protobuf::FieldOptions.extension_fields.map(&:name)).to include(:boom)
+      added_extension = Google::Protobuf::FieldOptions.extension_fields.detect { |f| f.fully_qualified_name == :'.test.pkg.code_generator_spec.boom' }
+      expect(added_extension.name).to eq(:boom)
+      expect(added_extension.rule).to eq(:optional)
+      expect(added_extension.type_class).to eq(::Protobuf::Field::StringField)
+      expect(added_extension.tag).to eq(20100)
     end
   end
 
   context 'class-level printing methods' do
     describe '.fatal' do
       it 'raises a CodeGeneratorFatalError error' do
-        expect {
+        expect do
           described_class.fatal("something is wrong")
-        }.to raise_error(
+        end.to raise_error(
           ::Protobuf::CodeGenerator::CodeGeneratorFatalError,
           "something is wrong"
         )
@@ -51,10 +79,9 @@ describe ::Protobuf::CodeGenerator do
 
     describe '.warn' do
       it 'prints a warning to stderr' do
-        STDERR.should_receive(:puts).with("[WARN] a warning")
+        expect(STDERR).to receive(:puts).with("[WARN] a warning")
         described_class.warn("a warning")
       end
     end
   end
-
 end

data/spec/lib/protobuf/enum_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
+require PROTOS_PATH.join('enum.pb')
 
-describe Protobuf::Enum do
+RSpec.describe Protobuf::Enum do
 
   describe 'class dsl' do
     let(:name) { :THREE }
@@ -22,7 +23,7 @@ describe Protobuf::Enum do
 
     describe '.aliases_allowed?' do
       it 'is false when the option is not set' do
-        expect(Test::EnumTestType.aliases_allowed?).to be_false
+        expect(Test::EnumTestType.aliases_allowed?).to be false
       end
     end
 
@@ -40,40 +41,45 @@ describe Protobuf::Enum do
         end
 
         it 'allows defining enums with the same tag number' do
-          expect {
+          expect do
             DefineEnumAlias.define(:FOO, 1)
             DefineEnumAlias.define(:BAR, 1)
-          }.not_to raise_error
+          end.not_to raise_error
         end
       end
     end
 
     describe '.enums' do
       it 'provides an array of defined Enums' do
-        expect(Test::EnumTestType.enums).to eq([
-          Test::EnumTestType::ONE,
-          Test::EnumTestType::TWO,
-          Test::EnumTestType::MINUS_ONE,
-          Test::EnumTestType::THREE
-        ])
+        expect(Test::EnumTestType.enums).to eq(
+          [
+            Test::EnumTestType::ZERO,
+            Test::EnumTestType::ONE,
+            Test::EnumTestType::TWO,
+            Test::EnumTestType::MINUS_ONE,
+            Test::EnumTestType::THREE,
+          ]
+        )
       end
 
       context 'when enum allows aliases' do
         it 'treats aliased enums as valid' do
-          expect(EnumAliasTest.enums).to eq([
-            EnumAliasTest::FOO,
-            EnumAliasTest::BAR,
-            EnumAliasTest::BAZ
-          ])
+          expect(EnumAliasTest.enums).to eq(
+            [
+              EnumAliasTest::FOO,
+              EnumAliasTest::BAR,
+              EnumAliasTest::BAZ,
+            ]
+          )
         end
       end
     end
 
-
     describe '.enums_for_tag' do
       it 'returns an array of Enums for the given tag, if any' do
-        expect(EnumAliasTest.enums_for_tag(1)).to eq([ EnumAliasTest::FOO, EnumAliasTest::BAR ])
-        expect(EnumAliasTest.enums_for_tag(2)).to eq([ EnumAliasTest::BAZ ])
+        expect(EnumAliasTest.enums_for_tag(nil)).to eq([])
+        expect(EnumAliasTest.enums_for_tag(1)).to eq([EnumAliasTest::FOO, EnumAliasTest::BAR])
+        expect(EnumAliasTest.enums_for_tag(2)).to eq([EnumAliasTest::BAZ])
         expect(EnumAliasTest.enums_for_tag(3)).to eq([])
       end
     end
@@ -120,6 +126,7 @@ describe Protobuf::Enum do
       it 'gets the Enum corresponding to the given tag' do
         expect(Test::EnumTestType.enum_for_tag(tag)).to eq(Test::EnumTestType.const_get(name))
         expect(Test::EnumTestType.enum_for_tag(-5)).to be_nil
+        expect(Test::EnumTestType.enum_for_tag(nil)).to be_nil
       end
     end
 
@@ -155,15 +162,15 @@ describe Protobuf::Enum do
 
     describe '.valid_tag?' do
       context 'when tag is defined' do
-        specify { expect(Test::EnumTestType.valid_tag?(tag)).to be_true }
+        specify { expect(Test::EnumTestType.valid_tag?(tag)).to be true }
       end
 
       context 'when tag is not defined' do
-        specify { expect(Test::EnumTestType.valid_tag?(300)).to be_false }
+        specify { expect(Test::EnumTestType.valid_tag?(300)).to be false }
       end
 
       context 'is true for aliased enums' do
-        specify { expect(EnumAliasTest.valid_tag?(1)).to be_true }
+        specify { expect(EnumAliasTest.valid_tag?(1)).to be true }
       end
     end
 
@@ -174,21 +181,27 @@ describe Protobuf::Enum do
     end
 
     describe '.values' do
+      around do |example|
+        # this method is deprecated
+        ::Protobuf.deprecator.silence(&example)
+      end
+
       it 'provides a hash of defined Enums' do
-        expect(Test::EnumTestType.values).to eq({
+        expect(Test::EnumTestType.values).to eq(
           :MINUS_ONE => Test::EnumTestType::MINUS_ONE,
+          :ZERO      => Test::EnumTestType::ZERO,
           :ONE       => Test::EnumTestType::ONE,
           :TWO       => Test::EnumTestType::TWO,
           :THREE     => Test::EnumTestType::THREE
-        })
+        )
       end
 
       it 'contains aliased Enums' do
-        expect(EnumAliasTest.values).to eq({
+        expect(EnumAliasTest.values).to eq(
           :FOO => EnumAliasTest::FOO,
           :BAR => EnumAliasTest::BAR,
           :BAZ => EnumAliasTest::BAZ
-        })
+        )
       end
     end
 
@@ -200,37 +213,55 @@ describe Protobuf::Enum do
     end
   end
 
-	subject { Test::EnumTestType::ONE }
-  its(:class) { should eq(Fixnum) }
-  its(:parent_class) { should eq(Test::EnumTestType) }
-	its(:name) { should eq(:ONE) }
-	its(:tag) { should eq(1) }
-	its(:value) { should eq(1) }
-	its(:to_hash_value) { should eq(1) }
-	its(:to_s) { should eq("1") }
-	its(:inspect) { should eq('#<Protobuf::Enum(Test::EnumTestType)::ONE=1>') }
-  specify { subject.to_s(:tag).should eq("1") }
-  specify { subject.to_s(:name).should eq("ONE") }
+  subject { Test::EnumTestType::ONE }
+  specify { expect(subject.class).to eq(Fixnum) }
+  specify { expect(subject.parent_class).to eq(Test::EnumTestType) }
+  specify { expect(subject.name).to eq(:ONE) }
+  specify { expect(subject.tag).to eq(1) }
+
+  context 'deprecated' do
+    around do |example|
+      # this method is deprecated
+      ::Protobuf.deprecator.silence(&example)
+    end
+
+    specify { expect(subject.value).to eq(1) }
+  end
+
+  specify { expect(subject.to_hash_value).to eq(1) }
+  specify { expect(subject.to_s).to eq("1") }
+  specify { expect(subject.inspect).to eq('#<Protobuf::Enum(Test::EnumTestType)::ONE=1>') }
+  specify { expect(subject.to_s(:tag)).to eq("1") }
+  specify { expect(subject.to_s(:name)).to eq("ONE") }
 
   it "can be used as the index to an array" do
     array = [0, 1, 2, 3]
-    array[::Test::EnumTestType::ONE].should eq(1)
+    expect(array[::Test::EnumTestType::ONE]).to eq(1)
   end
 
   describe '#try' do
-    specify { subject.try(:parent_class).should eq(subject.parent_class) }
-    specify { subject.try(:class).should eq(subject.class) }
-    specify { subject.try(:name).should eq(subject.name) }
-    specify { subject.try(:tag).should eq(subject.tag) }
-    specify { subject.try(:value).should eq(subject.value) }
-    specify { subject.try(:to_i).should eq(subject.to_i) }
-    specify { subject.try(:to_int).should eq(subject.to_int) }
-    specify { subject.try { |yielded| yielded.should eq(subject) } }
+    specify { expect(subject.try(:parent_class)).to eq(subject.parent_class) }
+    specify { expect(subject.try(:class)).to eq(subject.class) }
+    specify { expect(subject.try(:name)).to eq(subject.name) }
+    specify { expect(subject.try(:tag)).to eq(subject.tag) }
+
+    context 'deprecated' do
+      around do |example|
+        # this method is deprecated
+        ::Protobuf.deprecator.silence(&example)
+      end
+
+      specify { expect(subject.try(:value)).to eq(subject.value) }
+    end
+
+    specify { expect(subject.try(:to_i)).to eq(subject.to_i) }
+    specify { expect(subject.try(:to_int)).to eq(subject.to_int) }
+    specify { subject.try { |yielded| expect(yielded).to eq(subject) } }
   end
 
   context 'when coercing from enum' do
     subject { Test::StatusType::PENDING }
-    it { should eq(0) }
+    it { is_expected.to eq(0) }
   end
 
   context 'when coercing from integer' do

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

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::BoolField do
+
+  it_behaves_like :packable_field, described_class do
+    let(:value) { [true, false] }
+  end
+
+  class SomeBoolMessage < ::Protobuf::Message
+    optional :bool, :some_bool, 1
+    required :bool, :required_bool, 2
+  end
+
+  let(:instance) { SomeBoolMessage.new }
+
+  describe 'setting and getting field' do
+    subject { instance.some_bool = value; instance.some_bool }
+
+    [true, false].each do |val|
+      context "when set with #{val}" do
+        let(:value) { val }
+
+        it 'is readable as a bool' do
+          expect(subject).to eq(val)
+        end
+      end
+    end
+
+    [['true', true], ['false', false]].each do |val, expected|
+      context "when set with a string of #{val}" do
+        let(:value) { val }
+
+        it 'is readable as a bool' do
+          expect(subject).to eq(expected)
+        end
+      end
+    end
+
+    context 'when set with a non-bool string' do
+      let(:value) { "aaaa" }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when set with something that is not a bool' do
+      let(:value) { [1, 2, 3] }
+
+      it 'throws an error' do
+        expect { subject }.to raise_error(TypeError)
+      end
+    end
+  end
+
+  it 'defines ? method' do
+    instance.required_bool = false
+    expect(instance.required_bool?).to be(false)
+  end
+
+  describe '#default_value' do
+    context 'optional and required fields' do
+      it 'returns the class default' do
+        expect(SomeBoolMessage.get_field('some_bool').default).to be nil
+        expect(::Protobuf::Field::BoolField.default).to be false
+        expect(instance.some_bool).to be false
+      end
+
+      context 'with field default' do
+        class AnotherBoolMessage < ::Protobuf::Message
+          optional :bool, :set_bool, 1, :default => true
+        end
+
+        it 'returns the set default' do
+          expect(AnotherBoolMessage.get_field('set_bool').default).to be true
+          expect(AnotherBoolMessage.new.set_bool).to be true
+        end
+      end
+    end
+
+    context 'repeated field' do
+      class RepeatedBoolMessage < ::Protobuf::Message
+        repeated :bool, :repeated_bool, 1
+      end
+
+      it 'returns the set default' do
+        expect(RepeatedBoolMessage.new.repeated_bool).to eq []
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::EnumField do
+  let(:message) do
+    Class.new(::Protobuf::Message) do
+      enum_class = Class.new(::Protobuf::Enum) do
+        define :POSITIVE, 22
+        define :NEGATIVE, -33
+      end
+
+      optional enum_class, :enum, 1
+    end
+  end
+
+  describe '.{encode, decode}' do
+    it 'handles positive enum constants' do
+      instance = message.new(:enum => :POSITIVE)
+      expect(message.decode(instance.encode).enum).to eq(22)
+    end
+
+    it 'handles negative enum constants' do
+      instance = message.new(:enum => :NEGATIVE)
+      expect(message.decode(instance.encode).enum).to eq(-33)
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::FieldArray do
+
+  class SomeBasicMessage < ::Protobuf::Message
+    optional :string, :field, 1
+  end
+
+  class MoreComplexMessage < SomeBasicMessage
+  end
+
+  class OtherBasicMessage < ::Protobuf::Message
+    optional :string, :other_field, 1
+  end
+
+  class SomeRepeatMessage < ::Protobuf::Message
+    optional :string, :some_string, 1
+    repeated :string, :multiple_strings, 2
+    repeated SomeBasicMessage, :multiple_basic_msgs, 3
+  end
+
+  let(:instance) { SomeRepeatMessage.new }
+
+  %w(<< push).each do |method|
+    describe "\##{method}" do
+      context 'when applied to a string field array' do
+        it 'adds a string' do
+          expect(instance.multiple_strings).to be_empty
+          instance.multiple_strings.send(method, 'string 1')
+          expect(instance.multiple_strings).to eq(['string 1'])
+          instance.multiple_strings.send(method, 'string 2')
+          expect(instance.multiple_strings).to eq(['string 1', 'string 2'])
+        end
+
+        it 'fails if not adding a string' do
+          expect { instance.multiple_strings.send(method, 100.0) }.to raise_error(TypeError)
+        end
+      end
+
+      context 'when applied to a MessageField field array' do
+        it 'adds a MessageField object' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = SomeBasicMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg1)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+          basic_msg2 = SomeBasicMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg2)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1, basic_msg2])
+        end
+
+        it 'adds a Hash from a MessageField object' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = SomeBasicMessage.new
+          basic_msg1.field = 'my value'
+          instance.multiple_basic_msgs.send(method, basic_msg1.to_hash)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+        end
+
+        it 'does not downcast a MessageField' do
+          expect(instance.multiple_basic_msgs).to be_empty
+          basic_msg1 = MoreComplexMessage.new
+          instance.multiple_basic_msgs.send(method, basic_msg1)
+          expect(instance.multiple_basic_msgs).to eq([basic_msg1])
+          expect(instance.multiple_basic_msgs.first).to be_a(MoreComplexMessage)
+        end
+      end
+    end
+  end
+end