protobuf-cucumber 3.10.4

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

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/base'
+
+RSpec.describe ::Protobuf::Generators::Base do
+
+  subject(:generator) { described_class.new(double) }
+
+  context 'namespaces' do
+    let(:descriptor) { double(:name => '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
+    it 'protects the block from being entered more than once' do
+      foo = 0
+      bar = 0
+
+      test_run_once = lambda do
+        bar += 1
+        subject.run_once(:foo_test) do
+          foo += 1
+        end
+      end
+
+      10.times { test_run_once.call }
+      expect(foo).to eq(1)
+      expect(bar).to eq(10)
+    end
+
+    it 'always returns the same object' do
+      rv = subject.run_once(:foo_test) do
+        "foo bar"
+      end
+      expect(rv).to eq("foo bar")
+
+      rv = subject.run_once(:foo_test) do
+        "baz quux"
+      end
+      expect(rv).to eq("foo bar")
+    end
+  end
+
+  describe '#to_s' do
+    before do
+      class ToStringTest < ::Protobuf::Generators::Base
+        def compile
+          run_once(:compile) do
+            puts "this is a test"
+          end
+        end
+      end
+    end
+
+    subject { ToStringTest.new(double) }
+
+    it 'compiles and returns the contents' do
+      10.times do
+        expect(subject.to_s).to eq("this is a test\n")
+      end
+    end
+  end
+
+  describe '#validate_tags' do
+    context 'when tags are duplicated' do
+      it 'fails with a GeneratorFatalError' do
+        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
+        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
+
+  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

@@ -0,0 +1,82 @@
+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, 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
+        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
+
+    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

@@ -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], 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) }
+
+  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/generators/field_generator_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+require 'protobuf/generators/field_generator'
+
+RSpec.describe ::Protobuf::Generators::FieldGenerator do
+
+  let(:label_enum) { :LABEL_OPTIONAL }
+  let(:name) { 'foo_bar' }
+  let(:number) { 3 }
+  let(:type_enum) { :TYPE_STRING }
+  let(:type_name) { nil }
+  let(:default_value) { nil }
+  let(:extendee) { nil }
+  let(: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) }
+
+  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, owner_msg, 1).to_s }
+
+    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" }
+    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" }
+
+      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" }
+      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\"" }
+
+        specify { expect(subject).to eq "  optional :string, :foo_bar, 3, :default => \"a default \"string\"\"\n" }
+      end
+
+      context 'when float or double field type' do
+        let(:type_enum) { :TYPE_DOUBLE }
+
+        context 'when the default value is "nan"' do
+          let(:default_value) { 'nan' }
+          specify { expect(subject).to match(/::Float::NAN/) }
+        end
+
+        context 'when the default value is "inf"' do
+          let(:default_value) { 'inf' }
+          specify { expect(subject).to match(/::Float::INFINITY/) }
+        end
+
+        context 'when the default value is "-inf"' do
+          let(:default_value) { '-inf' }
+          specify { expect(subject).to match(/-::Float::INFINITY/) }
+        end
+      end
+    end
+
+    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" }
+    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" }
+    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" }
+    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