protobuf 2.0.0.rc2 → 2.0.0.rc3

data/lib/protobuf/rpc/server.rb

@@ -20,7 +20,7 @@ module Protobuf
 
         # Call the service method
         log_debug { "[#{log_signature}] Dispatching client request to service" }
-        ::GC.disable if ::Protobuf.gc_pause_server_request
+        ::GC.disable if ::Protobuf.gc_pause_server_request?
         invoke_rpc_method
       rescue => error
         # Ensure we're handling any errors that try to slip out the back door
@@ -133,7 +133,7 @@ module Protobuf
         @stats.log_stats
         @did_respond = true
       ensure
-        ::GC.enable if ::Protobuf.gc_pause_server_request
+        ::GC.enable if ::Protobuf.gc_pause_server_request?
       end
     end
   end

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.0.0.rc2'
+  VERSION = '2.0.0.rc3'
   PROTOC_VERSION = '2.4.1'
 end

data/spec/benchmark/tasks.rb

@@ -1,6 +1,6 @@
 require 'benchmark'
 require 'support/all'
-require 'proto/test_service_impl'
+require 'support/test/resource_service'
 require 'perftools'
 
 # Including a way to turn on debug logger for spec runs
@@ -11,7 +11,6 @@ if ENV["DEBUG"]
 end
 
 namespace :benchmark do
-  include SilentConstants
 
   def benchmark_wrapper(global_bench = nil)
     if global_bench
@@ -28,7 +27,7 @@ namespace :benchmark do
 
     EventMachine.fiber_run do 
       StubServer.new do |server|
-        client = Spec::Proto::TestService.client(:async => false)
+        client = ::Test::ResourceService.client(:async => false)
 
         benchmark_wrapper(global_bench) do |bench|
           bench.report("ES / EC") do 
@@ -46,7 +45,7 @@ namespace :benchmark do
 
     EventMachine.fiber_run do
       StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server| 
-        client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+        client = ::Test::ResourceService.client(:async => false, :port => 9399)
 
         benchmark_wrapper(global_bench) do |bench|
           bench.report("SS / EC") do 
@@ -65,7 +64,7 @@ namespace :benchmark do
     EM.stop if EM.reactor_running?
 
     StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server| 
-      client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+      client = ::Test::ResourceService.client(:async => false, :port => 9399)
 
       benchmark_wrapper(global_bench) do |bench|
         bench.report("SS / SC") do 
@@ -83,7 +82,7 @@ namespace :benchmark do
     Thread.pass until EM.reactor_running?
 
     StubServer.new(:port => 9399) do |server| 
-      client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+      client = ::Test::ResourceService.client(:async => false, :port => 9399)
 
       benchmark_wrapper(global_bench) do |bench|
         bench.report("ES / SC") do 
@@ -100,7 +99,7 @@ namespace :benchmark do
     load "protobuf/zmq.rb"
     ::Protobuf::Rpc::Connector.connector_for_client(true)
     StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server| 
-      client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+      client = ::Test::ResourceService.client(:async => false, :port => 9399)
 
       benchmark_wrapper(global_bench) do |bench|
         bench.report("ZS / ZC") do 
@@ -132,7 +131,7 @@ namespace :benchmark do
     args.with_defaults(:number => 1000, :profile_output => "/tmp/profiler_new_#{Time.now.to_i}")
     create_params = { :name => "The name that we set", :date_created => Time.now.to_i, :status => 2 }
     ::PerfTools::CpuProfiler.start(args[:profile_output]) do 
-      args[:number].to_i.times { Spec::Proto::Resource.new(create_params) }
+      args[:number].to_i.times { Test::Resource.new(create_params) }
     end
 
     puts args[:profile_output]

data/spec/functional/evented_server_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 
 describe 'Functional EventMachine Client' do
   before(:each) do
     load 'protobuf/evented.rb'
     ::Protobuf::Rpc::Connector.connector_for_client(true)
-    ::Spec::Proto::TestService.configure(::Spec::Proto::TestService::DEFAULT_LOCATION)
+    ::Test::ResourceService.configure(::Test::ResourceService::DEFAULT_LOCATION)
   end
 
   it 'runs fine when required fields are set' do
     expect {
       EventMachine.fiber_run do
         StubServer.new do |server|
-          client = ::Spec::Proto::TestService.client(:async => false, :timeout => 5)
+          client = ::Test::ResourceService.client(:async => false, :timeout => 5)
 
           client.find(:name => 'Test Name', :active => true) do |c|
             c.on_success do |succ|
               succ.name.should eq("Test Name")
-              succ.status.should eq(::Spec::Proto::StatusType::ENABLED)
+              succ.status.should eq(::Test::StatusType::ENABLED)
             end
 
             c.on_failure do |err|
@@ -34,8 +34,8 @@ describe 'Functional EventMachine Client' do
     error = nil
     EventMachine.fiber_run do
       StubServer.new do |server|
-        request = ::Spec::Proto::ResourceFindRequest.new(:active => true)
-        client = ::Spec::Proto::TestService.client(:async => false)
+        request = ::Test::ResourceFindRequest.new(:active => true)
+        client = ::Test::ResourceService.client(:async => false)
 
         client.find(request) do |c|
           c.on_success { raise "shouldn't pass"}
@@ -44,15 +44,15 @@ describe 'Functional EventMachine Client' do
       end
       EM.stop
     end
-    error.message.should =~ /ResourceFindRequest.*fields.*improperly set.*"name"/
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set/
   end
 
   it 'calls the on_failure callback when the request type is wrong' do
     error = nil
     EventMachine.fiber_run do
       StubServer.new do |server|
-        request = ::Spec::Proto::Resource.new(:name => 'Test Name')
-        client = ::Spec::Proto::TestService.client(:async => false)
+        request = ::Test::Resource.new(:name => 'Test Name')
+        client = ::Test::ResourceService.client(:async => false)
 
         client.find(request) do |c|
           c.on_success { raise "shouldn't pass"}

data/spec/functional/socket_server_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 
 describe 'Functional Socket Client' do
   before(:all) do
@@ -18,12 +18,12 @@ describe 'Functional Socket Client' do
 
   it 'runs fine when required fields are set' do
     expect {
-      client = ::Spec::Proto::TestService.client(:async => false)
+      client = ::Test::ResourceService.client(:async => false)
 
       client.find(:name => 'Test Name', :active => true) do |c|
         c.on_success do |succ|
           succ.name.should eq("Test Name")
-          succ.status.should eq(::Spec::Proto::StatusType::ENABLED)
+          succ.status.should eq(::Test::StatusType::ENABLED)
         end
 
         c.on_failure do |err|
@@ -35,20 +35,20 @@ describe 'Functional Socket Client' do
 
   it 'calls the on_failure callback when a message is malformed' do
     error = nil
-    request = ::Spec::Proto::ResourceFindRequest.new(:active => true)
-    client = ::Spec::Proto::TestService.client(:async => false)
+    request = ::Test::ResourceFindRequest.new(:active => true)
+    client = ::Test::ResourceService.client(:async => false)
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}
       c.on_failure {|e| error = e}
     end
-    error.message.should =~ /ResourceFindRequest.*fields.*improperly set.*"name"/
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set/
   end
 
   it 'calls the on_failure callback when the request type is wrong' do
     error = nil
-    request = ::Spec::Proto::Resource.new(:name => 'Test Name')
-    client = ::Spec::Proto::TestService.client(:async => false)
+    request = ::Test::Resource.new(:name => 'Test Name')
+    client = ::Test::ResourceService.client(:async => false)
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}

data/spec/functional/zmq_server_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 
 describe 'Functional ZMQ Client' do
   before(:all) do
@@ -18,12 +18,12 @@ describe 'Functional ZMQ Client' do
 
   it 'runs fine when required fields are set' do
     expect {
-      client = ::Spec::Proto::TestService.client(:async => false)
+      client = ::Test::ResourceService.client(:async => false)
 
       client.find(:name => 'Test Name', :active => true) do |c|
         c.on_success do |succ|
           succ.name.should eq("Test Name")
-          succ.status.should eq(::Spec::Proto::StatusType::ENABLED)
+          succ.status.should eq(::Test::StatusType::ENABLED)
         end
 
         c.on_failure do |err|
@@ -35,20 +35,20 @@ describe 'Functional ZMQ Client' do
 
   it 'calls the on_failure callback when a message is malformed' do
     error = nil
-    request = ::Spec::Proto::ResourceFindRequest.new(:active => true)
-    client = ::Spec::Proto::TestService.client(:async => false)
+    request = ::Test::ResourceFindRequest.new(:active => true)
+    client = ::Test::ResourceService.client(:async => false)
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}
       c.on_failure {|e| error = e}
     end
-    error.message.should =~ /ResourceFindRequest.*fields.*improperly set.*"name"/
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set/
   end
 
   it 'calls the on_failure callback when the request type is wrong' do
     error = nil
-    request = ::Spec::Proto::Resource.new(:name => 'Test Name')
-    client = ::Spec::Proto::TestService.client(:async => false)
+    request = ::Test::Resource.new(:name => 'Test Name')
+    client = ::Test::ResourceService.client(:async => false)
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}

data/spec/lib/protobuf/cli_spec.rb

@@ -92,8 +92,7 @@ describe ::Protobuf::CLI do
 
 				it 'sets both request and serialization pausing to false' do
 					described_class.start(args)
-					::Protobuf.gc_pause_server_request.should be_false
-					::Protobuf.gc_pause_server_serialization.should be_false
+					::Protobuf.gc_pause_server_request?.should be_false
 				end
 			end
 
@@ -102,18 +101,38 @@ describe ::Protobuf::CLI do
 
 				it 'sets the configuration option to GC pause server request' do
 					described_class.start(args)
-					::Protobuf.gc_pause_server_request.should be_true
+					::Protobuf.gc_pause_server_request?.should be_true
 				end
 			end
+		end
 
-			context 'serialization pausing' do
-				let(:test_args) { [ '--gc_pause_serialization' ] }
-
-				it 'sets the configuration option to GC pause server serializations' do
-					described_class.start(args)
-					::Protobuf.gc_pause_server_serialization.should be_true
-				end
-			end
+		context 'deprecation options' do
+      context 'when not given' do
+        let(:test_args) { [] }
+
+        it 'sets the deprecation warning flag to its default value' do
+          described_class.start(args)
+					::Protobuf.print_deprecation_warnings?.should be_true
+        end
+      end
+
+      context 'when enabled' do
+        let(:test_args) { [ '--print_deprecation_warnings' ] }
+
+        it 'sets the deprecation warning flag to true' do
+          described_class.start(args)
+					::Protobuf.print_deprecation_warnings?.should be_true
+        end
+      end
+
+      context 'when disabled' do
+        let(:test_args) { [ '--no-print_deprecation_warnings' ] }
+
+        it 'sets the deprecation warning flag to false' do
+          described_class.start(args)
+					::Protobuf.print_deprecation_warnings?.should be_false
+        end
+      end
 		end
 
 		context 'run modes' do

data/spec/lib/protobuf/enum_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Protobuf::Enum do
+  let(:name) { :THREE }
+  let(:tag) { 3 }
+
+  before(:all) do
+    Test::EnumTestType.define(name, tag)
+  end
+
+  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)
+    end
+  end
+
+  describe '.fetch' do
+    context 'when value is an EnumValue' do
+      it 'responds with that object' do
+        Test::EnumTestType.fetch(Test::EnumTestType::THREE).should eq Test::EnumTestType::THREE
+      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
+      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
+      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
+      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::THREE
+    end
+  end
+
+  describe '.name_by_value' do
+    it 'gets the name of the enum corresponding to the given value (tag)' do
+      Test::EnumTestType.name_by_value(tag).should eq name
+    end
+  end
+
+  describe '.valid_tag?' do
+    context 'when tag is defined' do
+      specify { Test::EnumTestType.valid_tag?(tag).should be_true }
+    end
+
+    context 'when tag is not defined' do
+      specify { Test::EnumTestType.valid_tag?(300).should be_false }
+    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
+    end
+  end
+
+  describe '.values' do
+    it 'provides a hash of defined EnumValues' do
+      Test::EnumTestType.values.should eq({
+        :ONE   => Test::EnumTestType::ONE,
+        :TWO   => Test::EnumTestType::TWO,
+        :THREE => Test::EnumTestType::THREE
+      })
+    end
+  end
+
+  context 'when coercing from enum' do
+    subject { Test::StatusType::PENDING }
+    it { should eq(0) }
+  end
+
+  context 'when coercing from integer' do
+    specify { 0.should eq(Test::StatusType::PENDING) }
+  end
+end

data/spec/lib/protobuf/enum_value_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Protobuf::EnumValue do
+
+	subject { Test::EnumTestType::ONE }
+	its(:parent_class) { should eq Test::EnumTestType }
+	its(:name) { should eq :ONE }
+	its(:value) { should eq 1 }
+	its(:to_hash_value) { should eq 1 }
+	its(:to_s) { should eq "ONE" }
+	its(:inspect) { should eq '#<Protobuf::EnumValue Test::EnumTestType::ONE=1>' }
+
+end

data/spec/lib/protobuf/message/encoder_spec.rb

@@ -7,7 +7,7 @@ end
 describe Protobuf::Encoder do
   describe '#encode' do
     context "when there's no value for a required field" do
-      let(:message) { ::Spec::Proto::Resource.new }
+      let(:message) { ::Test::Resource.new }
       let(:stream) { StringIO.new }
       it "raises a 'message not initialized' error" do
         expect {

data/spec/lib/protobuf/message_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Protobuf::Message do
+
+  describe '#to_hash' do
+    context 'generating values for an ENUM field' do
+      it 'converts the enum to its tag representation' do
+        hash = Test::EnumTestMessage.new(:non_default_enum => :TWO).to_hash
+        hash.should eq({ :non_default_enum => 2 })
+      end
+
+      it 'does not populate default values' do
+        hash = Test::EnumTestMessage.new.to_hash
+        hash.should eq(Hash.new)
+      end
+
+      it 'converts repeated enum fields to an array of the tags' do
+        hash = Test::EnumTestMessage.new(:repeated_enums => [ :ONE, :TWO, :TWO, :ONE ]).to_hash
+        hash.should eq({ :repeated_enums => [ 1, 2, 2, 1 ] })
+      end
+    end
+
+    context 'generating values for a Message field' do
+      it 'recursively hashes field messages' do
+        hash = Test::Nested.new({ :resource => { :name => 'Nested' } }).to_hash
+        hash.should eq({ :resource => { :name => 'Nested' } })
+      end
+
+      it 'recursively hashes a repeated set of messages' do
+        proto = Test::Nested.new(:multiple_resources => [
+          Test::Resource.new(:name => 'Resource 1'),
+          Test::Resource.new(:name => 'Resource 2')
+        ])
+
+        proto.to_hash.should eq({ :multiple_resources => [ { :name => 'Resource 1' },
+                                                           { :name => 'Resource 2' } ] })
+
+      end
+    end
+  end
+
+  describe '#to_json' do
+    subject do
+      ::Test::ResourceFindRequest.new({ :name => 'Test Name', :active => false })
+    end
+
+    its(:to_json) { should eq '{"name":"Test Name","active":false}' }
+  end
+
+end