protobuf 2.8.13 → 3.0.0.rc1

data/spec/lib/protobuf/field_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+require 'protobuf/field'
+
+describe ::Protobuf::Field do
+
+  describe '.build' do
+    pending
+  end
+
+  describe '.field_class' do
+    context 'when type is an enum class' do
+      it 'returns an enum field' do
+        expect(subject.field_class(::Test::EnumTestType)).to eq(::Protobuf::Field::EnumField)
+        expect(subject.field_type(::Test::EnumTestType)).to eq(::Test::EnumTestType)
+      end
+    end
+
+    context 'when type is a message class' do
+      it 'returns a message field' do
+        expect(subject.field_class(::Test::Resource)).to eq(::Protobuf::Field::MessageField)
+        expect(subject.field_type(::Test::Resource)).to eq(::Test::Resource)
+      end
+    end
+
+    context 'when type is a base field class' do
+      it 'returns that class' do
+        expect(subject.field_class(::Protobuf::Field::BoolField)).to eq(::Protobuf::Field::BoolField)
+      end
+    end
+
+    context 'when type is a double field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::DoubleField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:double)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:double)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a float field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::FloatField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:float)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:float)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a int32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Int32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:int32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:int32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a int64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Int64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:int64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:int64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a uint32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Uint32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:uint32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:uint32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a uint64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Uint64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:uint64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:uint64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sint32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sint32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sint32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sint32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sint64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sint64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sint64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sint64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a fixed32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Fixed32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:fixed32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:fixed32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a fixed64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Fixed64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:fixed64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:fixed64)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sfixed32 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sfixed32Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sfixed32)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sfixed32)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is a sfixed64 field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::Sfixed64Field
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:sfixed64)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:sfixed64)).to eq(expected_field)
+      end
+    end
+
+
+    context 'when type is a string field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::StringField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:string)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:string)).to eq(expected_field)
+      end
+    end
+
+
+    context 'when type is a bytes field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::BytesField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:bytes)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:bytes)).to eq(expected_field)
+      end
+    end
+
+
+    context 'when type is a bool field class or symbol' do
+      it 'returns that class' do
+        expected_field = ::Protobuf::Field::BoolField
+        expect(subject.field_class(expected_field)).to eq(expected_field)
+        expect(subject.field_class(:bool)).to eq(expected_field)
+        expect(subject.field_type(expected_field)).to eq(expected_field)
+        expect(subject.field_type(:bool)).to eq(expected_field)
+      end
+    end
+
+    context 'when type is not mapped' do
+      it 'raises an ArgumentError' do
+        expect {
+          subject.field_class("boom")
+        }.to raise_error
+      end
+    end
+
+  end
+
+end

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

@@ -11,8 +11,10 @@ describe ::Protobuf::Generators::EnumGenerator do
       { :name => 'BAZ', :number => 3 }
     ]
   }
+  let(:options) { nil }
   let(:enum_fields) { { :name => 'TestEnum',
-                        :value => values } }
+                        :value => values,
+                        :options => options } }
 
   let(:enum) { ::Google::Protobuf::EnumDescriptorProto.new(enum_fields) }
 
@@ -33,6 +35,27 @@ end
       subject.compile
       subject.to_s.should eq(compiled)
     end
+
+    context 'when allow_alias option is set' do
+      let(:compiled) {
+        %q{class TestEnum < ::Protobuf::Enum
+  set_option :allow_alias
+
+  define :FOO, 1
+  define :BAR, 2
+  define :BAZ, 3
+end
+
+}
+    }
+
+      let(:options) { { :allow_alias => true } }
+
+      it 'sets the allow_alias option' do
+        subject.compile
+        subject.to_s.should eq(compiled)
+      end
+    end
   end
 
   describe '#build_value' do

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

@@ -27,7 +27,7 @@ describe ::Protobuf::Generators::FieldGenerator do
   describe '#compile' do
     subject { described_class.new(field).to_s }
 
-    it { should eq "optional ::Protobuf::Field::StringField, :foo_bar, 3\n" }
+    it { should eq "optional :string, :foo_bar, 3\n" }
 
     context 'when the type is another message' do
       let(:type_enum) { :TYPE_MESSAGE }
@@ -39,7 +39,7 @@ describe ::Protobuf::Generators::FieldGenerator do
     context 'when a default value is used' do
       let(:type_enum) { :TYPE_INT32 }
       let(:default_value) { '42' }
-      it { should eq "optional ::Protobuf::Field::Int32Field, :foo_bar, 3, :default => 42\n" }
+      it { should eq "optional :int32, :foo_bar, 3, :default => 42\n" }
 
       context 'when type is an enum' do
         let(:type_enum) { :TYPE_ENUM }
@@ -53,7 +53,7 @@ describe ::Protobuf::Generators::FieldGenerator do
         let(:type_enum) { :TYPE_STRING }
         let(:default_value) { "a default \"string\"" }
 
-        it { should eq %Q{optional ::Protobuf::Field::StringField, :foo_bar, 3, :default => "a default \"string\""\n} }
+        it { should eq %Q{optional :string, :foo_bar, 3, :default => "a default \"string\""\n} }
       end
 
       context 'when float or double field type' do
@@ -79,19 +79,19 @@ describe ::Protobuf::Generators::FieldGenerator do
     context 'when the field is an extension' do
       let(:extendee) { 'foo.bar.Baz' }
 
-      it { should eq "optional ::Protobuf::Field::StringField, :foo_bar, 3, :extension => true\n" }
+      it { should 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 ::Protobuf::Field::StringField, :foo_bar, 3, :packed => true\n" }
+      it { should 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 ::Protobuf::Field::StringField, :foo_bar, 3, :deprecated => true\n" }
+      it { should eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
     end
   end
 

data/spec/lib/protobuf/message_spec.rb

@@ -10,13 +10,13 @@ describe Protobuf::Message do
     end
   end
 
-  describe '.define_field' do
+  describe 'defining a new field' do
     context 'when defining a field with a tag that has already been used' do
       it 'raises a TagCollisionError' do
         expect {
           Class.new(Protobuf::Message) do
-            define_field :optional, ::Protobuf::Field::Int32Field, :foo, 1, {}
-            define_field :optional, ::Protobuf::Field::Int32Field, :bar, 1, {}
+            optional ::Protobuf::Field::Int32Field, :foo, 1
+            optional ::Protobuf::Field::Int32Field, :bar, 1
           end
         }.to raise_error(Protobuf::TagCollisionError, /Field number 1 has already been used/)
       end
@@ -27,8 +27,8 @@ describe Protobuf::Message do
         expect {
           Class.new(Protobuf::Message) do
             extensions 100...110
-            define_field :optional, ::Protobuf::Field::Int32Field, :foo, 100, {}
-            define_field :optional, ::Protobuf::Field::Int32Field, :bar, 100, :extension => true
+            optional ::Protobuf::Field::Int32Field, :foo, 100
+            optional ::Protobuf::Field::Int32Field, :bar, 100, :extension => true
           end
         }.to raise_error(Protobuf::TagCollisionError, /Field number 100 has already been used/)
       end
@@ -38,8 +38,8 @@ describe Protobuf::Message do
       it 'raises a DuplicateFieldNameError' do
         expect {
           Class.new(Protobuf::Message) do
-            define_field :optional, ::Protobuf::Field::Int32Field, :foo, 1, {}
-            define_field :optional, ::Protobuf::Field::Int32Field, :foo, 2, {}
+            optional ::Protobuf::Field::Int32Field, :foo, 1
+            optional ::Protobuf::Field::Int32Field, :foo, 2
           end
         }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
       end
@@ -50,8 +50,8 @@ describe Protobuf::Message do
         expect {
           Class.new(Protobuf::Message) do
             extensions 100...110
-            define_field :optional, ::Protobuf::Field::Int32Field, :foo, 1, {}
-            define_field :optional, ::Protobuf::Field::Int32Field, :foo, 100, :extension => true
+            optional ::Protobuf::Field::Int32Field, :foo, 1
+            optional ::Protobuf::Field::Int32Field, :foo, 100, :extension => true
           end
         }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
       end
@@ -289,44 +289,9 @@ describe Protobuf::Message do
     its(:to_json) { should eq '{"name":"Test Name","active":false}' }
   end
 
-  describe '.to_json' do
-    it 'returns the class name of the message for use in json encoding' do
-      expect {
-        ::Timeout.timeout(0.1) do
-          expect(::Test::Resource.to_json).to eq("Test::Resource")
-        end
-      }.not_to raise_error
-    end
-  end
-
-  describe '#get_field_by_name' do
-    subject do
-      ::Test::Resource.new({ :name => 'Test Name', :date_created => Time.now.to_i })
-    end
-
-    context 'when name is a valid field' do
-      let(:valid_field) { subject.get_field_by_name(:name) }
-      specify { valid_field.should be_a ::Protobuf::Field::StringField }
-      specify { valid_field.name.should eq :name }
-    end
-
-    context 'when name is not a valid field' do
-      specify do
-        subject.get_field_by_name(1).should be_nil
-      end
-
-      specify do
-        subject.get_field_by_name(:nothere).should be_nil
-      end
-
-      specify do
-        subject.get_field_by_name(nil).should be_nil
-      end
-    end
-  end
-
   describe "#define_setter" do
     subject { ::Test::Resource.new }
+
     it "allows string fields to be set to nil" do
       expect { subject.name = nil }.to_not raise_error
     end
@@ -336,40 +301,57 @@ describe Protobuf::Message do
     end
   end
 
-  describe '#get_ext_field_by_name' do
-    pending 'Need to get a proto compiled with extensions first'
+  describe '.get_extension_field' do
+    it 'fetches an extension field by its tag' do
+      field = ::Test::Resource.get_extension_field(100)
+      expect(field).to be_a(::Protobuf::Field::BoolField)
+      expect(field.tag).to eq(100)
+      expect(field.name).to eq(:ext_is_searchable)
+      expect(field).to be_extension
+    end
+
+    it 'fetches an extension field by its symbolized name' do
+      expect(::Test::Resource.get_extension_field(:ext_is_searchable)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_extension_field('ext_is_searchable')).to be_a(::Protobuf::Field::BoolField)
+    end
+
+    it 'returns nil when attempting to get a non-extension field' do
+      expect(::Test::Resource.get_extension_field(1)).to be_nil
+    end
+
+    it 'returns nil when field is not found' do
+      ::Test::Resource.get_extension_field(-1).should be_nil
+      ::Test::Resource.get_extension_field(nil).should be_nil
+    end
   end
 
-  describe '#get_field_by_tag' do
-    subject do
-      ::Test::Resource.new({ :name => 'Test Name', :date_created => Time.now.to_i })
+  describe '.get_field' do
+    it 'fetches a non-extension field by its tag' do
+      field = ::Test::Resource.get_field(1)
+      expect(field).to be_a(::Protobuf::Field::StringField)
+      expect(field.tag).to eq(1)
+      expect(field.name).to eq(:name)
+      expect(field).not_to be_extension
     end
 
-    context 'when tag references a valid field' do
-      let(:valid_field) { subject.get_field_by_tag(1) }
-      specify { valid_field.should be_a ::Protobuf::Field::StringField }
-      specify { valid_field.name.should eq :name }
+    it 'fetches a non-extension field by its symbolized name' do
+      expect(::Test::Resource.get_field(:name)).to be_a(::Protobuf::Field::StringField)
+      expect(::Test::Resource.get_field('name')).to be_a(::Protobuf::Field::StringField)
     end
 
-    context 'when tag does not reference a field' do
-      it 'returns nil' do
-        pending 'need to implement a range-limiting array sub-class for field access'
-        subject.get_field_by_tag(-1).should be_nil
-      end
+    it 'fetches an extension field when forced' do
+      expect(::Test::Resource.get_field(100, true)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_field(:ext_is_searchable, true)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_field('ext_is_searchable', true)).to be_a(::Protobuf::Field::BoolField)
     end
 
-    context 'when tag is not numeric' do
-      specify do
-        expect {
-          subject.get_field_by_tag("not a number")
-        }.to raise_error(::Protobuf::FieldNotDefinedError, /.*not a number.*#{subject.class.name}/)
-      end
+    it 'returns nil when attempting to get an extension field' do
+      expect(::Test::Resource.get_field(100)).to be_nil
+    end
 
-      specify do
-        expect {
-          subject.get_field_by_tag(nil)
-        }.to raise_error(::Protobuf::FieldNotDefinedError, /.*nil.*#{subject.class.name}/)
-      end
+    it 'returns nil when field is not defined' do
+      ::Test::Resource.get_field(-1).should be_nil
+      ::Test::Resource.get_field(nil).should be_nil
     end
   end
 

data/spec/lib/protobuf/optionable_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'protobuf/optionable'
+
+describe 'Optionable' do
+
+  describe '.set_option' do
+    before(:all) do
+      OptionableSetOptionTest = ::Class.new do
+        include ::Protobuf::Optionable
+      end
+    end
+
+    it 'stores the given option and value' do
+      expect(OptionableSetOptionTest).to respond_to(:set_option)
+      expect(OptionableSetOptionTest.method(:set_option).arity).to eq(-2)
+      expect {
+        OptionableSetOptionTest.set_option(:foo, :bar)
+      }.to_not raise_error
+    end
+
+    it 'defaults the value to true' do
+      OptionableSetOptionTest.set_option(:baz_enabled)
+      expect(OptionableSetOptionTest.get_option(:baz_enabled)).to be_true
+    end
+  end
+
+  describe '.get_option' do
+    before(:all) do
+      OptionableGetOptionTest = ::Class.new do
+        include ::Protobuf::Optionable
+        set_option :foo, :bar
+      end
+    end
+
+    it 'retrieves the option for the given name, if any' do
+      expect(OptionableGetOptionTest.get_option(:foo)).to eq(:bar)
+      expect(OptionableGetOptionTest.get_option(:baz)).to be_nil
+    end
+
+    it 'retrieves the option in the context of an instance' do
+      expect(OptionableGetOptionTest.new.get_option(:foo)).to eq(:bar)
+      expect(OptionableGetOptionTest.new.get_option(:baz)).to be_nil
+    end
+  end
+
+end

data/spec/lib/protobuf/rpc/client_spec.rb

@@ -3,99 +3,7 @@ require 'spec/support/test/resource_service'
 
 describe Protobuf::Rpc::Client do
   before(:each) do
-    load 'protobuf/evented.rb'
-  end
-
-  context "when using fiber based calls", :skip => true do
-    it "waits for response" do
-      EventMachine.fiber_run do
-        StubServer.new(:delay => 1) do |server|
-          client = Test::ResourceService.client
-          start = now
-
-          client.find(:name => "Test Name", :active => true) do |c|
-            c.on_success do |succ|
-              succ.name.should eq("Test Name")
-              succ.status.should eq(Test::StatusType::ENABLED)
-            end
-
-            c.on_failure do |err|
-              raise err.inspect
-            end
-          end
-
-          (now - start).should be_within(server.options.delay * 0.10).of(server.options.delay)
-        end
-
-        EM.stop
-      end
-    end
-
-    it "throws and error when call is attempted without 'EventMachine.fiber_run'" do
-      subject = Proc.new do
-        EventMachine.run do
-          StubServer.new(:delay => 1) do |server|
-            client = Test::ResourceService.client
-            client.find(:name => "Test Name", :active => true)
-          end
-        end
-      end
-
-      subject.should raise_error(RuntimeError, /EM.fiber_run/)
-    end
-
-    it "throws a timeout when client timeout is exceeded" do
-      error = nil
-      test_proc = Proc.new do
-        EventMachine.fiber_run do
-          StubServer.new(:delay => 2) do |server|
-            client = Test::ResourceService.client(:timeout => 1)
-            client.find(:name => "Test Name", :active => true) do |cl|
-              cl.on_success {}
-              cl.on_failure {|f| error = f}
-            end
-          end
-          EM.stop
-        end
-      end
-
-      test_proc.call
-      error.message.should =~ /timeout/i
-    end
-
-    context "without reactor_running?" do
-
-      it "throws a timeout when client timeout is exceeded" do
-        subject = Proc.new do
-          StubServer.new(:delay => 2) do |server|
-            client = Test::ResourceService.client(:timeout => 1)
-            client.find(:name => "Test Name", :active => true)
-          end
-        end
-
-        subject.should raise_error(RuntimeError, /timeout/i)
-      end
-
-      it "calls failure_cb & throws a timeout when client timeout is exceeded" do
-        failure_message = nil
-
-        subject = Proc.new do
-          StubServer.new(:delay => 2) do |server|
-            client = Test::ResourceService.client(:timeout => 1)
-            client.find(:name => "Test Name", :active => true) do |c|
-              c.on_failure do |f|
-                failure_message = f.message
-              end
-            end
-          end
-        end
-
-        subject.call
-        failure_message.should match(/timeout/)
-      end
-
-    end
-
+    load 'protobuf/socket.rb'
   end
 
   context 'when creating a client from a service' do

data/spec/lib/protobuf/rpc/connector_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'protobuf/socket'
-require 'protobuf/evented'
 require 'protobuf/zmq'
 
 describe ::Protobuf::Rpc::Connector do
@@ -14,15 +13,10 @@ describe ::Protobuf::Rpc::Connector do
     end
 
     context 'Protobuf.connector_type is not a known value' do
-      before { ::Protobuf.connector_type = :socket }
+      before { ::Protobuf.stub(:connector_type) { :foo } }
       it { should eq ::Protobuf::Rpc::Connectors::Socket }
     end
 
-    context 'Protobuf.connector_type is evented' do
-      before { ::Protobuf.connector_type = :evented }
-      it { should eq ::Protobuf::Rpc::Connectors::EventMachine }
-    end
-
     context 'Protobuf.connector_type is zmq' do
       before { ::Protobuf.connector_type = :zmq }
       it { should eq ::Protobuf::Rpc::Connectors::Zmq }

data/spec/lib/protobuf/rpc/connectors/zmq_spec.rb

@@ -28,6 +28,14 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
     ::ZMQ::Context.stub(:new).and_return(zmq_context_double)
   end
 
+  before(:all) do
+    @ping_port_before = ENV['PB_RPC_PING_PORT']
+  end
+
+  after(:all) do
+    ENV['PB_RPC_PING_PORT'] = @ping_port_before
+  end
+
   describe "#lookup_server_uri" do
     let(:service_directory) { double('ServiceDirectory', :running? => running? ) }
     let(:listing) { double('Listing', :address => '127.0.0.2', :port => 9399) }