prepor-protobuf 3.5.0

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/base'
+
+RSpec.describe ::Protobuf::Generators::Base do
+
+  subject { 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
+        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

data/spec/lib/protobuf/generators/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/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], 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/generators/field_generator_spec.rb

@@ -0,0 +1,102 @@
+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) }
+
+  describe '#compile' do
+    subject { described_class.new(field).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 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 deprecated' do
+      let(:field_options) { { :deprecated => true } }
+
+      specify { expect(subject).to eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
+    end
+  end
+
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+require 'protobuf/generators/file_generator'
+
+RSpec.describe ::Protobuf::Generators::FileGenerator do
+
+  let(:base_descriptor_fields) { { :name => 'test/foo.proto' } }
+  let(:descriptor_fields) { base_descriptor_fields }
+  let(:file_descriptor) { ::Google::Protobuf::FileDescriptorProto.new(descriptor_fields) }
+
+  subject { described_class.new(file_descriptor) }
+  specify { expect(subject.file_name).to eq('test/foo.pb.rb') }
+
+  describe '#print_import_requires' do
+    let(:descriptor_fields) do
+      base_descriptor_fields.merge(
+        :dependency => [
+          'test/bar.proto',
+          'test/baz.proto',
+        ],
+      )
+    end
+
+    it 'prints a ruby require for each dependency' do
+      expect(subject).to receive(:print_require).with('test/bar.pb')
+      expect(subject).to receive(:print_require).with('test/baz.pb')
+      subject.print_import_requires
+    end
+
+  end
+
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+require 'protobuf/generators/service_generator'
+
+RSpec.describe ::Protobuf::Generators::ServiceGenerator do
+
+  let(:methods) do
+    [
+      { :name => 'Search', :input_type => 'FooRequest', :output_type => 'FooResponse' },
+      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' },
+    ]
+  end
+  let(:service_fields) do
+    {
+      :name => 'TestService',
+      :method => methods,
+    }
+  end
+
+  let(:service) { ::Google::Protobuf::ServiceDescriptorProto.new(service_fields) }
+
+  subject { described_class.new(service) }
+
+  describe '#compile' do
+    let(:compiled) do
+      'class TestService < ::Protobuf::Rpc::Service
+  rpc :search, FooRequest, FooResponse
+  rpc :foo_bar, ::Foo::Request, ::Bar::Response
+end
+
+'
+    end
+
+    it 'compiles the service and it\'s rpc methods' do
+      subject.compile
+      expect(subject.to_s).to eq(compiled)
+    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
+  end
+
+end

data/spec/lib/protobuf/lifecycle_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'protobuf/lifecycle'
+
+RSpec.describe ::Protobuf::Lifecycle do
+  subject { described_class }
+
+  around do |example|
+    # this entire class is deprecated
+    ::Protobuf.deprecator.silence(&example)
+  end
+
+  before do
+    ::ActiveSupport::Notifications.notifier = ::ActiveSupport::Notifications::Fanout.new
+  end
+
+  it "registers a string as the event_name" do
+    expect(::ActiveSupport::Notifications).to receive(:subscribe).with("something")
+    subject.register("something") { true }
+  end
+
+  it "only registers blocks for event callbacks" do
+    expect do
+      subject.register("something")
+    end.to raise_error(/block/)
+  end
+
+  it "calls the registered block when triggered" do
+    this = nil
+    subject.register("this") do
+      this = "not nil"
+    end
+
+    subject.trigger("this")
+    expect(this).to_not be_nil
+    expect(this).to eq("not nil")
+  end
+
+  it "calls multiple registered blocks when triggered" do
+    this = nil
+    that = nil
+
+    subject.register("this") do
+      this = "not nil"
+    end
+
+    subject.register("this") do
+      that = "not nil"
+    end
+
+    subject.trigger("this")
+    expect(this).to_not be_nil
+    expect(this).to eq("not nil")
+    expect(that).to_not be_nil
+    expect(that).to eq("not nil")
+  end
+
+  context 'when the registered block has arity' do
+    context 'and the triggered event does not have args' do
+      it 'does not pass the args' do
+        outer_bar = nil
+
+        subject.register('foo') do |bar|
+          expect(bar).to be_nil
+          outer_bar = 'triggered'
+        end
+
+        subject.trigger('foo')
+        expect(outer_bar).to eq 'triggered'
+      end
+    end
+
+    context 'and the triggered event has arguments' do
+      it 'does not pass the args' do
+        outer_bar = nil
+
+        subject.register('foo') do |bar|
+          expect(bar).to_not be_nil
+          outer_bar = bar
+        end
+
+        subject.trigger('foo', 'baz')
+        expect(outer_bar).to eq 'baz'
+      end
+    end
+  end
+
+  context "normalized event names" do
+    specify { expect(subject.normalized_event_name(:derp)).to eq("derp") }
+    specify { expect(subject.normalized_event_name(:Derp)).to eq("derp") }
+    specify { expect(subject.normalized_event_name("DERP")).to eq("derp") }
+    specify { expect(subject.normalized_event_name("derp")).to eq("derp") }
+  end
+
+end