protobuf 2.0.0.rc2 → 2.0.0.rc3

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

@@ -1,24 +1,24 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 
 describe Protobuf::Rpc::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
 
   context "when using fiber based calls" do
     it "waits for response when running synchronously" do
       EventMachine.fiber_run do
         StubServer.new(:delay => 3) do |server|
-          client = Spec::Proto::TestService.client(:async => false)
+          client = Test::ResourceService.client(:async => false)
           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(Spec::Proto::StatusType::ENABLED)
+              succ.status.should eq(Test::StatusType::ENABLED)
             end
 
             c.on_failure do |err|
@@ -36,7 +36,7 @@ describe Protobuf::Rpc::Client do
     it "doesn't wait for response when running async call inside fiber" do
       EventMachine.fiber_run do
         StubServer.new(:delay => 3) do |server|
-          client = Spec::Proto::TestService.client(:async => true)
+          client = Test::ResourceService.client(:async => true)
           start = now
           client.find(:name => "Test Name", :active => true)
 
@@ -50,7 +50,7 @@ describe Protobuf::Rpc::Client do
       subject = Proc.new do
         EventMachine.run do
           StubServer.new(:delay => 1) do |server|
-            client = Spec::Proto::TestService.client(:async => false)
+            client = Test::ResourceService.client(:async => false)
             client.find(:name => "Test Name", :active => true)
           end
         end
@@ -64,7 +64,7 @@ describe Protobuf::Rpc::Client do
       test_proc = Proc.new do
         EventMachine.fiber_run do
           StubServer.new(:delay => 2) do |server|
-            client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
+            client = Test::ResourceService.client(:async => false, :timeout => 1)
             client.find(:name => "Test Name", :active => true) do |cl|
               cl.on_success {}
               cl.on_failure {|f| error = f}
@@ -83,7 +83,7 @@ describe Protobuf::Rpc::Client do
       it "throws a timeout when client timeout is exceeded" do
         subject = Proc.new do
           StubServer.new(:delay => 2) do |server|
-            client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
+            client = Test::ResourceService.client(:async => false, :timeout => 1)
             client.find(:name => "Test Name", :active => true)
           end
         end
@@ -96,7 +96,7 @@ describe Protobuf::Rpc::Client do
 
         subject = Proc.new do
           StubServer.new(:delay => 2) do |server|
-            client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
+            client = Test::ResourceService.client(:async => false, :timeout => 1)
             client.find(:name => "Test Name", :active => true) do |c|
               c.on_failure do |f|
                 failure_message = f.message
@@ -116,38 +116,38 @@ describe Protobuf::Rpc::Client do
   context 'when creating a client from a service' do
 
     it 'should be able to get a client through the Service#client helper method' do
-      Spec::Proto::TestService.client(:port => 9191).should eq(Protobuf::Rpc::Client.new(:service => Spec::Proto::TestService, :port => 9191))
+      Test::ResourceService.client(:port => 9191).should eq(Protobuf::Rpc::Client.new(:service => Test::ResourceService, :port => 9191))
     end
 
     it "should be able to override a service location's host and port" do
-      Spec::Proto::TestService.located_at 'somewheregreat.com:12345'
-      clean_client = Spec::Proto::TestService.client
+      Test::ResourceService.located_at 'somewheregreat.com:12345'
+      clean_client = Test::ResourceService.client
       clean_client.options[:host].should eq('somewheregreat.com')
       clean_client.options[:port].should eq(12345)
 
-      updated_client = Spec::Proto::TestService.client(:host => 'amazing.com', :port => 54321)
+      updated_client = Test::ResourceService.client(:host => 'amazing.com', :port => 54321)
       updated_client.options[:host].should eq('amazing.com')
       updated_client.options[:port].should eq(54321)
     end
 
     it 'should be able to define the syncronicity of the client request' do
-      client = Spec::Proto::TestService.client(:async => false)
+      client = Test::ResourceService.client(:async => false)
       client.options[:async].should be_false
       client.async?.should be_false
 
-      client = Spec::Proto::TestService.client(:async => true)
+      client = Test::ResourceService.client(:async => true)
       client.options[:async].should be_true
       client.async?.should be_true
     end
 
     it 'should be able to define which service to create itself for' do
-      client = Protobuf::Rpc::Client.new :service => Spec::Proto::TestService
-      client.options[:service].should eq(Spec::Proto::TestService)
+      client = Protobuf::Rpc::Client.new :service => Test::ResourceService
+      client.options[:service].should eq(Test::ResourceService)
     end
 
     it 'should have a hard default for host and port on a service that has not been configured' do
-      reset_service_location Spec::Proto::TestService
-      client = Spec::Proto::TestService.client
+      reset_service_location Test::ResourceService
+      client = Test::ResourceService.client
       client.options[:host].should eq(Protobuf::Rpc::Service::DEFAULT_LOCATION[:host])
       client.options[:port].should eq(Protobuf::Rpc::Service::DEFAULT_LOCATION[:port])
     end
@@ -161,7 +161,7 @@ describe Protobuf::Rpc::Client do
     # namely the :find method
 
     it 'should respond to defined service methods' do
-      client = Spec::Proto::TestService.client
+      client = Test::ResourceService.client
       client.should_receive(:send_request).and_return(nil)
       expect { client.find(nil) }.to_not raise_error
     end
@@ -173,7 +173,7 @@ describe Protobuf::Rpc::Client do
     it 'should be able to set and get local variables within client response blocks' do
       outer_value = 'OUTER'
       inner_value = 'INNER'
-      client = Spec::Proto::TestService.client(:async => true)
+      client = Test::ResourceService.client(:async => true)
 
       EM.should_receive(:reactor_running?).and_return(true)
       EM.stub!(:next_tick) do
@@ -194,10 +194,10 @@ describe Protobuf::Rpc::Client do
   context 'when receiving request objects' do
 
     it 'should be able to create the correct request object if passed a hash' do
-      client = Spec::Proto::TestService.client
+      client = Test::ResourceService.client
       client.should_receive(:send_request)
       client.find({:name => 'Test Name', :active => false})
-      client.options[:request].should be_a(Spec::Proto::ResourceFindRequest)
+      client.options[:request].should be_a(Test::ResourceFindRequest)
       client.options[:request].name.should eq('Test Name')
       client.options[:request].active.should eq(false)
     end

data/spec/lib/protobuf/rpc/servers/evented_server_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 require 'protobuf/rpc/servers/evented_runner'
 require 'protobuf/evented'
 

data/spec/lib/protobuf/rpc/servers/socket_server_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 require 'protobuf/rpc/servers/socket_runner'
 require 'protobuf/evented'
 require 'protobuf/socket'

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

@@ -1,45 +1,45 @@
 require 'spec_helper'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 
 describe Protobuf::Rpc::Service do
 
   context 'when configuring' do
     before :each do
-      reset_service_location Spec::Proto::TestService
+      reset_service_location Test::ResourceService
     end
 
     it 'should have a default location configured' do
-      Spec::Proto::TestService.host.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
-      Spec::Proto::TestService.port.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
+      Test::ResourceService.host.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
+      Test::ResourceService.port.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
     end
 
     it "should be able to pre-configure a service location for clients" do
-      Spec::Proto::TestService.located_at 'google.com:12345'
-      client = Spec::Proto::TestService.client
+      Test::ResourceService.located_at 'google.com:12345'
+      client = Test::ResourceService.client
       client.options[:host].should == 'google.com'
       client.options[:port].should == 12345
     end
 
     context 'configuring host' do
-      before(:each) { Spec::Proto::TestService.configure :host => 'somehost.com' }
-      after(:each) { Spec::Proto::TestService.configure :host => '127.0.0.1' }
+      before(:each) { Test::ResourceService.configure :host => 'somehost.com' }
+      after(:each) { Test::ResourceService.configure :host => '127.0.0.1' }
 
       it 'should be able to configure and read the host' do
-        Spec::Proto::TestService.host.should == 'somehost.com'
+        Test::ResourceService.host.should == 'somehost.com'
       end
     end
 
     it 'should be able to configure and read the port' do
-      Spec::Proto::TestService.configure :port => 12345
-      Spec::Proto::TestService.port.should == 12345
+      Test::ResourceService.configure :port => 12345
+      Test::ResourceService.port.should == 12345
     end
 
     it 'should skip configuring location if the location passed does not match host:port syntax' do
       invalid_locations = [nil, 'myhost:', ':9939', 'badhost123']
       invalid_locations.each do |location|
-        Spec::Proto::TestService.located_at location
-        Spec::Proto::TestService.host.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
-        Spec::Proto::TestService.port.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
+        Test::ResourceService.located_at location
+        Test::ResourceService.host.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
+        Test::ResourceService.port.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
       end
     end
   end
@@ -48,8 +48,8 @@ describe Protobuf::Rpc::Service do
 
     before(:all) do
       class ::NewTestService < Protobuf::Rpc::Service
-        rpc :bad_method, Spec::Proto::ResourceFindRequest, Spec::Proto::Resource
-        rpc :bad_var, Spec::Proto::ResourceFindRequest, Spec::Proto::Resource
+        rpc :bad_method, Test::ResourceFindRequest, Test::Resource
+        rpc :bad_var, Test::ResourceFindRequest, Test::Resource
         def bad_method
           hash = {}
           hash[:one].explode
@@ -62,14 +62,14 @@ describe Protobuf::Rpc::Service do
 
     it 'raises an undefined method name error when calling a method on a non-existant object' do
       expect {
-        req = mock('RequestWrapper', :request_proto => Spec::Proto::ResourceFindRequest.new(:name => 'mmeh').to_s)
+        req = mock('RequestWrapper', :request_proto => Test::ResourceFindRequest.new(:name => 'mmeh').to_s)
         ::NewTestService.new.bad_method(req)
       }.to raise_error(NoMethodError)
     end
 
     it 'raises a name error when accessing a non-existant object' do
       expect {
-        req = mock('RequestWrapper', :request_proto => Spec::Proto::ResourceFindRequest.new(:name => 'mmeh').to_s)
+        req = mock('RequestWrapper', :request_proto => Test::ResourceFindRequest.new(:name => 'mmeh').to_s)
         ::NewTestService.new.bad_var(req)
       }.to raise_error(NameError)
     end

data/spec/lib/protobuf_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'protobuf'
+
+describe ::Protobuf do
+
+  describe '.connector_type' do
+    before { described_class.instance_variable_set(:@_connector_type, nil) }
+
+    it 'defaults to socket' do
+      described_class.connector_type.should eq :socket
+    end
+
+    it 'accepts socket, evented, or zmq' do
+      [:socket, :evented, :zmq].each do |type|
+        described_class.connector_type = type
+        described_class.connector_type.should eq type
+      end
+    end
+
+    it 'does not accept other types' do
+      [:hello, :world].each do |type|
+        expect {
+          described_class.connector_type = type
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '.gc_pause_server_request?' do
+    before { described_class.instance_variable_set(:@_gc_pause_server_request, nil) }
+
+    it 'defaults to a false value' do
+      described_class.gc_pause_server_request?.should be_false
+    end
+
+    it 'is settable' do
+      described_class.gc_pause_server_request = true
+      described_class.gc_pause_server_request?.should be_true
+    end
+  end
+
+  describe '.print_deprecation_warnings?' do
+    before { described_class.instance_variable_set(:@_print_deprecation_warnings, nil) }
+
+    it 'defaults to a true value' do
+      described_class.print_deprecation_warnings?.should be_true
+    end
+
+    it 'is settable' do
+      described_class.print_deprecation_warnings = false
+      described_class.print_deprecation_warnings?.should be_false
+    end
+
+    context 'when ENV["PB_IGNORE_DEPRECATIONS"] present' do
+      it 'defaults to a false value' do
+        ENV['PB_IGNORE_DEPRECATIONS'] = '1'
+        described_class.print_deprecation_warnings?.should be_false
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -19,9 +19,20 @@ if ENV["DEBUG"]
 end
 
 ::RSpec.configure do |c|
-  c.include(::SilentConstants)
   c.include(::Sander6::CustomMatchers)
   c.mock_with :rspec
+
+  c.before(:suite) do
+    unless ENV['NO_COMPILE_TEST_PROTOS']
+      $stdout.puts 'Compiling test protos (use NO_COMPILE_TEST_PROTOS=1 to skip)'
+      proto_path = File.expand_path("../support/", __FILE__)
+      %x{ rprotoc --proto_path=#{proto_path} --ruby_out=#{proto_path} #{File.join(proto_path, '**', '*.proto')} }
+    end
+  end
+end
+
+Dir[File.expand_path('../support/**/*.pb.rb', __FILE__)].each do |proto_file|
+  require proto_file
 end
 
 class ::Protobuf::Rpc::Client

data/spec/support/all.rb

@@ -1,6 +1,5 @@
 require 'support/tolerance_matcher'
 require 'support/server'
-require 'support/silent_constants'
 
 def now
   Time.new.to_f

data/spec/support/server.rb

@@ -5,7 +5,7 @@ require 'protobuf/rpc/servers/socket/server'
 require 'protobuf/rpc/servers/socket_runner'
 require 'protobuf/rpc/servers/zmq/server'
 require 'protobuf/rpc/servers/zmq_runner'
-require 'spec/proto/test_service_impl'
+require 'spec/support/test/resource_service'
 
 # Want to abort if server dies?
 Thread.abort_on_exception = true

data/spec/support/test/enum.pb.rb

@@ -0,0 +1,32 @@
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+
+module Test
+  ##
+  # Enum Classes
+  #
+  class EnumTestType < ::Protobuf::Enum; end
+  
+  ##
+  # Message Classes
+  #
+  class EnumTestMessage < ::Protobuf::Message; end
+  
+  ##
+  # Enum Values
+  #
+  ::Test::EnumTestType.define :ONE, 1
+  ::Test::EnumTestType.define :TWO, 2
+  
+  
+  ##
+  # Message Fields
+  #
+  ::Test::EnumTestMessage.optional(::Test::EnumTestType, :non_default_enum, 1)
+  ::Test::EnumTestMessage.optional(::Test::EnumTestType, :default_enum, 2, :default => ::Test::EnumTestType::ONE)
+  ::Test::EnumTestMessage.repeated(::Test::EnumTestType, :repeated_enums, 3)
+  
+  
+end

data/spec/support/test/enum.proto

@@ -0,0 +1,12 @@
+package test;
+
+enum EnumTestType {
+  ONE = 1;
+  TWO = 2;
+}
+
+message EnumTestMessage {
+  optional EnumTestType non_default_enum = 1;
+  optional EnumTestType default_enum = 2 [default=ONE];
+  repeated EnumTestType repeated_enums = 3;
+}

data/spec/support/test/resource.pb.rb

@@ -0,0 +1,52 @@
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+require 'protobuf/rpc/service'
+
+module Test
+  ##
+  # Enum Classes
+  #
+  class StatusType < ::Protobuf::Enum; end
+  
+  ##
+  # Message Classes
+  #
+  class ResourceFindRequest < ::Protobuf::Message; end
+  class Resource < ::Protobuf::Message; end
+  class Nested < ::Protobuf::Message; end
+  
+  ##
+  # Enum Values
+  #
+  ::Test::StatusType.define :PENDING, 0
+  ::Test::StatusType.define :ENABLED, 1
+  ::Test::StatusType.define :DISABLED, 2
+  ::Test::StatusType.define :DELETED, 3
+  
+  
+  ##
+  # Message Fields
+  #
+  ::Test::ResourceFindRequest.required(::Protobuf::Field::StringField, :name, 1)
+  ::Test::ResourceFindRequest.optional(::Protobuf::Field::BoolField, :active, 2)
+  
+  ::Test::Resource.required(::Protobuf::Field::StringField, :name, 1)
+  ::Test::Resource.optional(::Protobuf::Field::Int64Field, :date_created, 2)
+  ::Test::Resource.optional(::Test::StatusType, :status, 3)
+  ::Test::Resource.repeated(::Test::StatusType, :repeated_enum, 4)
+  
+  ::Test::Nested.optional(::Protobuf::Field::StringField, :name, 1)
+  ::Test::Nested.optional(::Test::Resource, :resource, 2)
+  ::Test::Nested.repeated(::Test::Resource, :multiple_resources, 3)
+  ::Test::Nested.optional(::Test::StatusType, :status, 4)
+  
+  
+  ##
+  # Services
+  #
+  class ResourceService < ::Protobuf::Rpc::Service
+    rpc :find, ::Test::ResourceFindRequest, ::Test::Resource
+  end
+end