protobuf 2.8.13 → 3.0.0.rc1

data/spec/benchmark/tasks.rb

@@ -1,4 +1,5 @@
 require 'benchmark'
+require 'protobuf/socket'
 require 'support/all'
 require 'support/test/resource_service'
 
@@ -28,43 +29,8 @@ namespace :benchmark do
     end
   end
 
-  def em_client_em_server(number_tests, test_length, global_bench = nil)
-    EM.stop if EM.reactor_running?
-
-    EventMachine.fiber_run do
-      StubServer.new(:server => Protobuf::Rpc::Evented::Server) do |server|
-        benchmark_wrapper(global_bench) do |bench|
-          bench.report("ES / EC") do
-            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
-          end
-        end
-      end
-
-      EM.stop
-    end
-  end
-
-  def em_client_sock_server(number_tests, test_length, global_bench = nil)
-    EM.stop if EM.reactor_running?
-
-    EventMachine.fiber_run do
-      StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
-        client = ::Test::ResourceService.client(:port => 9399)
-
-        benchmark_wrapper(global_bench) do |bench|
-          bench.report("SS / EC") do
-            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
-          end
-        end
-      end
-
-      EM.stop
-    end
-  end
-
   def sock_client_sock_server(number_tests, test_length, global_bench = nil)
     load "protobuf/socket.rb"
-    EM.stop if EM.reactor_running?
 
     StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
       client = ::Test::ResourceService.client(:port => 9399)
@@ -77,26 +43,6 @@ namespace :benchmark do
     end
   end
 
-  def sock_client_em_server(number_tests, test_length, global_bench = nil)
-    load "protobuf/socket.rb"
-    EM.stop if EM.reactor_running?
-    em_thread = Thread.new { EM.run }
-    Thread.pass until EM.reactor_running?
-
-    StubServer.new(:port => 9399) do |server|
-      client = ::Test::ResourceService.client(:port => 9399)
-
-      benchmark_wrapper(global_bench) do |bench|
-        bench.report("ES / SC") do
-          (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
-        end
-      end
-    end
-
-    EM.stop
-    Thread.kill(em_thread) if em_thread
-  end
-
   def zmq_client_zmq_server(number_tests, test_length, global_bench = nil)
     load "protobuf/zmq.rb"
     StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server|
@@ -149,40 +95,19 @@ namespace :benchmark do
     puts args[:profile_output]
   end
 
-  desc "benchmark EventMachine client with EventMachine server"
-  task :em_client_em_server, [:number, :length] do |t, args|
-    args.with_defaults(:number => 1000, :length => 100)
-    em_client_em_server(args[:number], args[:length])
-  end
-
-  desc "benchmark EventMachine client with Socket server"
-  task :em_client_sock_server, [:number, :length] do |t, args|
-    args.with_defaults(:number => 1000, :length => 100)
-    em_client_sock_server(args[:number], args[:length])
-  end
-
   desc "benchmark Socket client with Socket server"
   task :sock_client_sock_server, [:number, :length] do |t, args|
     args.with_defaults(:number => 1000, :length => 100)
     sock_client_sock_server(args[:number], args[:length])
   end
 
-  desc "benchmark Socket client with EventMachine server"
-  task :sock_client_em_server, [:number, :length] do |t, args|
-    args.with_defaults(:number => 1000, :length => 100)
-    sock_client_em_server(args[:number], args[:length])
-  end
-
   desc "benchmark server performance"
   task :servers, [:number, :length] do |t, args|
     args.with_defaults(:number => 1000, :length => 100)
 
     Benchmark.bm(10) do |bench|
-      # zmq_client_zmq_server(args[:number], args[:length], bench)
-      #      em_client_em_server(args[:number], args[:length], bench)
-      #      em_client_sock_server(args[:number], args[:length], bench)
+      zmq_client_zmq_server(args[:number], args[:length], bench)
       sock_client_sock_server(args[:number], args[:length], bench)
-      #      sock_client_em_server(args[:number], args[:length], bench)
     end
   end
 end

data/spec/functional/zmq_server_spec.rb

@@ -4,29 +4,21 @@ require 'spec/support/test/resource_service'
 require 'protobuf/rpc/service_directory'
 
 describe 'Functional ZMQ Client' do
-  let(:options) {{
-    :host => "127.0.0.1",
-    :port => 9399,
-    :worker_port => 9400,
-    :backlog => 100,
-    :threshold => 100,
-    :threads => 5
-  }}
-
-  let(:server) { ::Protobuf::Rpc::Zmq::Server.new(options) }
-  let!(:server_thread) { Thread.new(server) { |server| server.run } }
-
   before(:all) do
     load "protobuf/zmq.rb"
+    @runner = ::Protobuf::Rpc::ZmqRunner.new({ :host => "127.0.0.1",
+                                               :port => 9399,
+                                               :worker_port => 9408,
+                                               :backlog => 100,
+                                               :threshold => 100,
+                                               :threads => 5 })
+    @server_thread = Thread.new(@runner) { |runner| runner.run }
+    Thread.pass until @runner.running?
   end
 
-  before do
-    Thread.pass until server.running?
-  end
-
-  after do
-    server.stop
-    server_thread.join
+  after(:all) do
+    @runner.stop
+    @server_thread.join
   end
 
   it 'runs fine when required fields are set' do
@@ -47,8 +39,8 @@ describe 'Functional ZMQ Client' do
   end
 
   it 'runs under heavy load' do
-    100.times do |x|
-      50.times.map do |y|
+    10.times do |x|
+      5.times.map do |y|
         Thread.new do
           client = ::Test::ResourceService.client
 

data/spec/lib/protobuf/cli_spec.rb

@@ -7,28 +7,21 @@ describe ::Protobuf::CLI do
     File.expand_path('../../../support/test_app_file.rb', __FILE__)
   end
 
-  let(:sock_runner) { 
+  let(:sock_runner) {
     runner = double("SocketRunner", :register_signals => nil)
     runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
     runner
   }
 
-  let(:zmq_runner) { 
+  let(:zmq_runner) {
     runner = double "ZmqRunner", register_signals: nil
     runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
     runner
   }
 
-  let(:evented_runner) { 
-    runner = double "EventedRunner", register_signals: nil
-    runner.stub(:run) { ::Protobuf::Lifecycle.trigger( "after_server_bind" ) }
-    runner
-  }
-
   before(:each) do
     ::Protobuf::Rpc::SocketRunner.stub(:new) { sock_runner }
     ::Protobuf::Rpc::ZmqRunner.stub(:new) { zmq_runner }
-    ::Protobuf::Rpc::EventedRunner.stub(:new) { evented_runner }
   end
 
   describe '#start' do
@@ -176,7 +169,6 @@ describe ::Protobuf::CLI do
         let(:runner) { ::Protobuf::Rpc::SocketRunner }
 
         before do
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
           ::Protobuf::Rpc::ZmqRunner.should_not_receive(:new)
         end
 
@@ -185,7 +177,7 @@ describe ::Protobuf::CLI do
           described_class.start(args)
         end
 
-        it 'is activated by PB_SERVER_TYPE=Socket ENV variable' do 
+        it 'is activated by PB_SERVER_TYPE=Socket ENV variable' do
           ENV['PB_SERVER_TYPE'] = "Socket"
           runner.should_receive(:new).and_return(sock_runner)
           described_class.start(args)
@@ -198,40 +190,12 @@ describe ::Protobuf::CLI do
         end
       end
 
-      context 'evented' do
-        let(:test_args) { [ '--evented' ] }
-        let(:runner) { ::Protobuf::Rpc::EventedRunner }
-
-        before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
-          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:new)
-        end
-
-        it 'is activated by the --evented switch' do
-          runner.should_receive(:new).and_return(evented_runner)
-          described_class.start(args)
-        end
-
-        it 'is activated by PB_SERVER_TYPE=Evented ENV variable' do 
-          ENV['PB_SERVER_TYPE'] = "Evented"
-          runner.should_receive(:new).and_return(evented_runner)
-          described_class.start(args)
-          ENV.delete('PB_SERVER_TYPE')
-        end
-
-        it 'configures the connector type to be evented' do
-          load "protobuf/evented.rb"
-          ::Protobuf.connector_type.should == :evented
-        end
-      end
-
       context 'zmq workers only' do
         let(:test_args) { [ '--workers_only', '--zmq' ] }
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
           ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --workers_only switch' do
@@ -242,7 +206,7 @@ describe ::Protobuf::CLI do
           described_class.start(args)
         end
 
-        it 'is activated by PB_WORKERS_ONLY=1 ENV variable' do 
+        it 'is activated by PB_WORKERS_ONLY=1 ENV variable' do
           ENV['PB_WORKERS_ONLY'] = "1"
           runner.should_receive(:new) do |options|
             options[:workers_only].should be_true
@@ -259,7 +223,6 @@ describe ::Protobuf::CLI do
 
         before do
           ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --worker_port switch' do
@@ -277,7 +240,6 @@ describe ::Protobuf::CLI do
 
         before do
           ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --zmq switch' do
@@ -285,7 +247,7 @@ describe ::Protobuf::CLI do
           described_class.start(args)
         end
 
-        it 'is activated by PB_SERVER_TYPE=Zmq ENV variable' do 
+        it 'is activated by PB_SERVER_TYPE=Zmq ENV variable' do
           ENV['PB_SERVER_TYPE'] = "Zmq"
           runner.should_receive(:new)
           described_class.start(args)

data/spec/lib/protobuf/enum_spec.rb

@@ -1,98 +1,231 @@
 require 'spec_helper'
 
 describe Protobuf::Enum do
-  let(:name) { :THREE }
-  let(:tag)  { 3 }
 
-  before(:all) do
-    Test::EnumTestType.define(:MINUS_ONE, -1)
-    Test::EnumTestType.define(:THREE, 3)
-  end
+  describe 'class dsl' do
+    let(:name) { :THREE }
+    let(:tag)  { 3 }
 
-  describe '.define' do
-    it 'defines a constant enum value on the parent class' do
-      Test::EnumTestType.constants.should include(name)
-      Test::EnumTestType::THREE.should be_a(Protobuf::EnumValue)
+    before(:all) do
+      Test::EnumTestType.define(:MINUS_ONE, -1)
+      Test::EnumTestType.define(:THREE, 3)
     end
-  end
 
-  describe '.fetch' do
-    context 'when value is an EnumValue' do
-      it 'responds with that object' do
-        Test::EnumTestType.fetch(Test::EnumTestType::THREE).name.should eq Test::EnumTestType::THREE.name
+    before(:all) do
+      EnumAliasTest = ::Class.new(::Protobuf::Enum) do
+        set_option :allow_alias
+        define :FOO, 1
+        define :BAR, 1
+        define :BAZ, 2
       end
     end
 
-    context 'when value can be coerced to a symbol' do
-      it 'fetches based on the symbol name value' do
-        Test::EnumTestType.fetch("ONE").should eq Test::EnumTestType::ONE
-        Test::EnumTestType.fetch(:ONE).should eq Test::EnumTestType::ONE
+    describe '.aliases_allowed?' do
+      it 'is false when the option is not set' do
+        expect(Test::EnumTestType.aliases_allowed?).to be_false
       end
     end
 
-    context 'when value can be coerced to an integer' do
-      it 'fetches based on the integer tag value' do
-        Test::EnumTestType.fetch(3.0).should eq Test::EnumTestType::THREE
-        Test::EnumTestType.fetch(3).should eq Test::EnumTestType::THREE
+    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 {
+            DefineEnumAlias.define(:FOO, 1)
+            DefineEnumAlias.define(:BAR, 1)
+          }.not_to raise_error
+        end
       end
     end
 
-    context 'when value is not an applicable type' do
-      it 'returns a nil' do
-        Test::EnumTestType.fetch(Test::Resource.new).should be_nil
-        Test::EnumTestType.fetch(nil).should be_nil
-        Test::EnumTestType.fetch(false).should be_nil
+    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
-  end
 
-  describe '.enum_by_value' do
-    it 'gets the EnumValue corresponding to the given value (tag)' do
-      Test::EnumTestType.enum_by_value(tag).should eq Test::EnumTestType.const_get(name)
+
+    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
-  end
 
-  describe '.name_by_value' do
-    it 'get the name by value of the enum given the enum' do 
-      Test::EnumTestType.name_by_value(::Test::EnumTestType::THREE).should eq name
+    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
 
-    it 'gets the name of the enum corresponding to the given value (tag)' do
-      Test::EnumTestType.name_by_value(tag).should eq name
+    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
 
-    context 'when given name is nil' do
-      it 'returns a nil' do
-        Test::EnumTestType.name_by_value(nil).should be_nil
+    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
-  end
 
-  describe '.valid_tag?' do
-    context 'when tag is defined' do
-      specify { Test::EnumTestType.valid_tag?(tag).should be_true }
+    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
 
-    context 'when tag is not defined' do
-      specify { Test::EnumTestType.valid_tag?(300).should be_false }
+    describe '.values' do
+      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
-  end
 
-  describe '.value_by_name' do
-    it 'gets the EnumValue corresponding to the given name' do
-      Test::EnumTestType.value_by_name(name).should eq Test::EnumTestType::THREE
+    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
 
-  describe '.values' do
-    it 'provides a hash of defined EnumValues' do
-      Test::EnumTestType.values.should eq({
-        :MINUS_ONE => Test::EnumTestType::MINUS_ONE,
-        :ONE   => Test::EnumTestType::ONE,
-        :TWO   => Test::EnumTestType::TWO,
-        :THREE => Test::EnumTestType::THREE
-      })
-    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") }
+
+  it "can be used as the index to an array" do
+    array = [0, 1, 2, 3]
+    array[::Test::EnumTestType::ONE].should 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) } }
   end
 
   context 'when coercing from enum' do
@@ -101,6 +234,6 @@ describe Protobuf::Enum do
   end
 
   context 'when coercing from integer' do
-    specify { 0.should eq(Test::StatusType::PENDING) }
+    specify { expect(0).to eq(Test::StatusType::PENDING) }
   end
 end