protobuf-core 3.5.0

data/spec/lib/protobuf/enum_generator_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+require 'protobuf/generators/enum_generator'
+
+RSpec.describe ::Protobuf::Generators::EnumGenerator do
+
+  let(:values) do
+    [
+      { :name => 'FOO', :number => 1 },
+      { :name => 'BAR', :number => 2 },
+      { :name => 'BAZ', :number => 3 },
+    ]
+  end
+  let(:options) { nil }
+  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) do
+      <<-RUBY
+class TestEnum < ::Protobuf::Enum
+  define :FOO, 1
+  define :BAR, 2
+  define :BAZ, 3
+end
+
+      RUBY
+    end
+
+    it 'compiles the enum and its field values' do
+      subject.compile
+      expect(subject.to_s).to eq(compiled)
+    end
+
+    context 'when allow_alias option is set' do
+      let(:compiled) do
+        <<-RUBY
+class TestEnum < ::Protobuf::Enum
+  set_option :allow_alias
+
+  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
+        expect(subject.to_s).to eq(compiled)
+      end
+    end
+  end
+
+  describe '#build_value' do
+    it 'returns a string identifying the given enum value' do
+      expect(subject.build_value(enum.value.first)).to eq("define :FOO, 1")
+    end
+  end
+
+end

data/spec/lib/protobuf/enum_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Enum do
+
+  describe 'class dsl' do
+    let(:name) { :THREE }
+    let(:tag)  { 3 }
+
+    before(:all) do
+      Test::EnumTestType.define(:MINUS_ONE, -1)
+      Test::EnumTestType.define(:THREE, 3)
+    end
+
+    before(:all) do
+      EnumAliasTest = ::Class.new(::Protobuf::Enum) do
+        set_option :allow_alias
+        define :FOO, 1
+        define :BAR, 1
+        define :BAZ, 2
+      end
+    end
+
+    describe '.aliases_allowed?' do
+      it 'is nil when the option is not set' do
+        expect(Test::EnumTestType.aliases_allowed?).to be nil
+      end
+    end
+
+    describe '.define' do
+      it 'defines a constant enum on the parent class' do
+        expect(Test::EnumTestType.constants).to include(name)
+        expect(Test::EnumTestType::THREE).to be_a(Protobuf::Enum)
+      end
+
+      context 'when enum allows aliases' do
+        before(:all) do
+          DefineEnumAlias = ::Class.new(::Protobuf::Enum) do
+            set_option :allow_alias
+          end
+        end
+
+        it 'allows defining enums with the same tag number' do
+          expect do
+            DefineEnumAlias.define(:FOO, 1)
+            DefineEnumAlias.define(:BAR, 1)
+          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,
+          ],
+        )
+      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,
+            ],
+          )
+        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(3)).to eq([])
+      end
+    end
+
+    describe '.fetch' do
+      context 'when candidate is an Enum' do
+        it 'responds with the Enum' do
+          expect(Test::EnumTestType.fetch(Test::EnumTestType::THREE)).to eq(Test::EnumTestType::THREE)
+        end
+      end
+
+      context 'when candidate can be coerced to a symbol' do
+        it 'fetches based on the symbol name' do
+          expect(Test::EnumTestType.fetch("ONE")).to eq(Test::EnumTestType::ONE)
+          expect(Test::EnumTestType.fetch(:ONE)).to eq(Test::EnumTestType::ONE)
+        end
+      end
+
+      context 'when candidate can be coerced to an integer' do
+        it 'fetches based on the integer tag' do
+          expect(Test::EnumTestType.fetch(3.0)).to eq(Test::EnumTestType::THREE)
+          expect(Test::EnumTestType.fetch(3)).to eq(Test::EnumTestType::THREE)
+        end
+
+        context 'when enum allows aliases' do
+          it 'fetches the first defined Enum' do
+            expect(EnumAliasTest.fetch(1)).to eq(EnumAliasTest::FOO)
+          end
+        end
+      end
+
+      context 'when candidate is not an applicable type' do
+        it 'returns a nil' do
+          expect(Test::EnumTestType.fetch(EnumAliasTest::FOO)).to be_nil
+          expect(Test::EnumTestType.fetch(Test::Resource.new)).to be_nil
+          expect(Test::EnumTestType.fetch(nil)).to be_nil
+          expect(Test::EnumTestType.fetch(false)).to be_nil
+          expect(Test::EnumTestType.fetch(-10)).to be_nil
+        end
+      end
+    end
+
+    describe '.enum_for_tag' 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
+      end
+    end
+
+    describe '.name_for_tag' do
+      it 'get the name of the enum given the enum' do
+        expect(Test::EnumTestType.name_for_tag(::Test::EnumTestType::THREE)).to eq(name)
+      end
+
+      it 'gets the name of the enum corresponding to the given tag' do
+        expect(Test::EnumTestType.name_for_tag(tag)).to eq(name)
+      end
+
+      it 'gets the name when the tag is coercable to an int' do
+        expect(Test::EnumTestType.name_for_tag("3")).to eq(name)
+      end
+
+      it 'returns nil when tag does not correspond to a name' do
+        expect(Test::EnumTestType.name_for_tag(12345)).to be_nil
+      end
+
+      context 'when given name is nil' do
+        it 'returns a nil' do
+          expect(Test::EnumTestType.name_for_tag(nil)).to be_nil
+        end
+      end
+
+      context 'when enum allows aliases' do
+        it 'returns the first defined name for the given tag' do
+          expect(EnumAliasTest.name_for_tag(1)).to eq(:FOO)
+        end
+      end
+    end
+
+    describe '.valid_tag?' do
+      context 'when tag is defined' do
+        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 }
+      end
+
+      context 'is true for aliased enums' do
+        specify { expect(EnumAliasTest.valid_tag?(1)).to be true }
+      end
+    end
+
+    describe '.enum_for_name' do
+      it 'gets the Enum corresponding to the given name' do
+        expect(Test::EnumTestType.enum_for_name(name)).to eq(Test::EnumTestType::THREE)
+      end
+    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(
+          :MINUS_ONE => Test::EnumTestType::MINUS_ONE,
+          :ONE       => Test::EnumTestType::ONE,
+          :TWO       => Test::EnumTestType::TWO,
+          :THREE     => Test::EnumTestType::THREE,
+        )
+      end
+
+      it 'contains aliased Enums' do
+        expect(EnumAliasTest.values).to eq(
+          :FOO => EnumAliasTest::FOO,
+          :BAR => EnumAliasTest::BAR,
+          :BAZ => EnumAliasTest::BAZ,
+        )
+      end
+    end
+
+    describe '.all_tags' do
+      it 'provides a unique array of defined tags' do
+        expect(Test::EnumTestType.all_tags).to include(1, 2, -1, 3)
+        expect(EnumAliasTest.all_tags).to include(1, 2)
+      end
+    end
+  end
+
+  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]
+    expect(array[::Test::EnumTestType::ONE]).to eq(1)
+  end
+
+  describe '#try' do
+    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 { is_expected.to eq(0) }
+  end
+
+  context 'when coercing from integer' do
+    specify { expect(0).to eq(Test::StatusType::PENDING) }
+  end
+end

data/spec/lib/protobuf/extension_generator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/extension_generator'
+
+RSpec.describe ::Protobuf::Generators::ExtensionGenerator do
+
+  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"),
+    ]
+  end
+  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])
+  end
+
+  subject { described_class.new(message_type, field_descriptors, 0) }
+
+  describe '#compile' do
+    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
+      expect(subject.to_s).to eq(compiled)
+    end
+  end
+
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Field::Int32Field do
+
+  class SomeBoolMessage < ::Protobuf::Message
+    optional :bool, :some_bool, 1
+  end
+
+  let(:instance) { SomeBoolMessage.new }
+
+  describe '#define_setter' 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
+
+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