protobuf 1.4.2 → 2.0.0.rc1

data/spec/lib/protobuf/cli_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+require 'protobuf/cli'
+
+describe ::Protobuf::CLI do
+
+	let(:app_file) do
+		File.expand_path('../../../support/test_app_file.rb', __FILE__)
+	end
+
+	before do
+		::Protobuf::Rpc::SocketRunner.stub(:run)
+		::Protobuf::Rpc::ZmqRunner.stub(:run)
+		::Protobuf::Rpc::EventedRunner.stub(:run)
+	end
+
+	describe '#start' do
+		let(:base_args) { [ 'start', app_file ] }
+		let(:test_args) { [] }
+		let(:args) { base_args + test_args }
+
+		context 'host option' do
+			let(:test_args) { [ '--host=123.123.123.123' ] }
+
+			it 'sends the host option to the runner' do
+				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+					options.host.should eq '123.123.123.123'
+				end
+				described_class.start(args)
+			end
+		end
+
+		context 'port option' do
+			let(:test_args) { [ '--port=12345' ] }
+
+			it 'sends the port option to the runner' do
+				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+					options.port.should eq 12345
+				end
+				described_class.start(args)
+			end
+		end
+
+		context 'backlog option' do
+			let(:test_args) { [ '--backlog=500' ] }
+
+			it 'sends the backlog option to the runner' do
+				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+					options.backlog.should eq 500
+				end
+				described_class.start(args)
+			end
+		end
+
+		context 'threshold option' do
+			let(:test_args) { [ '--threshold=500' ] }
+
+			it 'sends the backlog option to the runner' do
+				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+					options.threshold.should eq 500
+				end
+				described_class.start(args)
+			end
+		end
+
+		context 'log options' do
+			let(:test_args) { [ '--log=mylog.log', '--level=0' ] }
+
+			it 'sends the log file and level options to the runner' do
+				::Protobuf::Logger.should_receive(:configure) do |options|
+					options[:file].should eq 'mylog.log'
+					options[:level].should eq 0
+				end
+				described_class.start(args)
+			end
+
+			context 'when debugging' do
+				let(:test_args) { [ '--level=3', '--debug' ] }
+
+				it 'overrides the log-level to DEBUG' do
+					::Protobuf::Logger.should_receive(:configure) do |options|
+						options[:level].should eq ::Logger::DEBUG
+					end
+					described_class.start(args)
+				end
+			end
+		end
+
+		context 'gc options' do
+
+			context 'when gc options are not present' do
+				let(:test_args) { [] }
+
+				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
+				end
+			end
+
+			context 'request pausing' do
+				let(:test_args) { [ '--gc_pause_request' ] }
+
+				it 'sets the configuration option to GC pause server request' do
+					described_class.start(args)
+					::Protobuf.gc_pause_server_request.should be_true
+				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
+		end
+
+		context 'run modes' do
+
+			context 'socket' do
+				let(:test_args) { [ '--socket' ] }
+
+				before do
+					::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+					::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
+				end
+
+				it 'is activated by the --socket switch' do
+					::Protobuf::Rpc::SocketRunner.should_receive(:run)
+					described_class.start(args)
+				end
+
+				it 'configures the connector type to be socket' do
+          load "protobuf/socket.rb"
+					::Protobuf.connector_type.should == :socket
+				end
+			end
+
+			context 'evented' do
+				let(:test_args) { [ '--evented' ] }
+
+				before do
+					::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
+					::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
+				end
+
+				it 'is activated by the --evented switch' do
+					::Protobuf::Rpc::EventedRunner.should_receive(:run)
+					described_class.start(args)
+				end
+
+				it 'configures the connector type to be evented' do
+          load "protobuf/evented.rb"
+					::Protobuf.connector_type.should == :evented
+				end
+			end
+
+			context 'zmq' do
+				let(:test_args) { [ '--zmq' ] }
+
+				before do
+					::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
+					::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+				end
+
+				it 'is activated by the --zmq switch' do
+					::Protobuf::Rpc::ZmqRunner.should_receive(:run)
+					described_class.start(args)
+				end
+
+				it 'configures the connector type to be zmq' do
+          load "protobuf/zmq.rb"
+					::Protobuf.connector_type.should == :zmq
+				end
+			end
+
+		end
+
+	end
+
+end

data/spec/{unit → lib/protobuf}/rpc/client_spec.rb

@@ -3,6 +3,8 @@ require 'spec/proto/test_service_impl'
 
 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)
   end
 
@@ -16,8 +18,8 @@ describe Protobuf::Rpc::Client do
           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) 
-            end 
+              succ.status.should eq(Spec::Proto::StatusType::ENABLED)
+            end
 
             c.on_failure do |err|
               raise err.inspect
@@ -76,7 +78,7 @@ describe Protobuf::Rpc::Client do
       error.message.should =~ /timeout/i
     end
 
-    context "without reactor_running?" do 
+    context "without reactor_running?" do
 
       it "throws a timeout when client timeout is exceeded" do
         subject = Proc.new do
@@ -154,7 +156,7 @@ describe Protobuf::Rpc::Client do
 
   context 'when calling methods on a service client' do
 
-    # NOTE: we are assuming the service methods are accurately 
+    # NOTE: we are assuming the service methods are accurately
     # defined inside spec/proto/test_service.rb,
     # namely the :find method
 

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'protobuf/socket'
+require 'protobuf/evented'
+require 'protobuf/zmq'
+
+describe ::Protobuf::Rpc::Connector do
+
+  describe '.connector_for_client(true)' do
+    after { described_class.instance_variable_set(:@_connector, nil) }
+
+    context 'Protobuf.connector_type is socket' do
+      it 'returns a socket connector class' do
+        ::Protobuf.connector_type = :socket
+        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::Socket
+      end
+    end
+
+    context 'Protobuf.connector_type is not a known value' do
+      it 'returns a socket connector class' do
+        ::Protobuf.stub(:connector_type).and_return('some value')
+        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::Socket
+      end
+    end
+
+    context 'Protobuf.connector_type is evented' do
+      it 'returns an eventmachine connector class' do
+        ::Protobuf.connector_type = :evented
+        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::EventMachine
+      end
+    end
+
+    context 'Protobuf.connector_type is zmq' do
+      it 'returns a zmq connector class' do
+        ::Protobuf.connector_type = :zmq
+        described_class.connector_for_client(true).should eq ::Protobuf::Rpc::Connectors::Zmq
+      end
+    end
+
+  end
+
+end

data/spec/{unit → lib/protobuf}/rpc/connectors/base_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe Protobuf::Rpc::Connectors::Base do
-  
+
   let(:opts) do
     { async: false, timeout: 60 }
   end
-  
+
   subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-  
-  describe "#send_request" do 
-    it "raising an error when 'send_request' is not overridden" do 
+
+  describe "#send_request" do
+    it "raising an error when 'send_request' is not overridden" do
       expect{ subject.send_request }.to raise_error(RuntimeError, /inherit a Connector/)
     end
 
-    it "does not raise error when 'send_request' is overridden" do 
+    it "does not raise error when 'send_request' is overridden" do
       new_sub = Class.new(subject.class){ def send_request; end }.new(opts)
       expect{ new_sub.send_request }.to_not raise_error
     end
@@ -26,7 +26,7 @@ describe Protobuf::Rpc::Connectors::Base do
       subject.failure_cb.should be_nil
     end
   end
-  
+
   describe '#success_cb' do
     it 'allows setting the success callback and calling it' do
       subject.success_cb.should be_nil
@@ -36,7 +36,7 @@ describe Protobuf::Rpc::Connectors::Base do
       expect { subject.success_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end
-  
+
   describe '#failure_cb' do
     it 'allows setting the failure callback and calling it' do
       subject.failure_cb.should be_nil
@@ -46,43 +46,43 @@ describe Protobuf::Rpc::Connectors::Base do
       expect { subject.failure_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end
-  
+
   describe '#async?' do
     context 'when provided options[:async] is false' do
       let(:opts) do
         { async: false, timeout: 60 }
       end
-  
+
       subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-    
+
       it 'returns false' do
         subject.async?.should be_false
       end
     end
-    
+
     context 'when provided options[:async] is true' do
       let(:opts) do
         { async: true, timeout: 60 }
       end
-  
+
       subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-    
+
       it 'returns true' do
         subject.async?.should be_true
       end
     end
-    
+
     context 'when options doesn\'t denote async' do
       let(:opts) do
         { timeout: 60 }
       end
-  
+
       subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-    
+
       it 'returns false' do
         subject.async?.should be_false
       end
     end
   end
-  
+
 end

data/spec/{unit → lib/protobuf}/rpc/connectors/common_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper' 
-require 'protobuf/rpc/service' 
+require 'spec_helper'
+require 'protobuf/rpc/service'
 
 describe Protobuf::Rpc::Connectors::Common do
-  let(:common_class) do 
+  let(:common_class) do
     Class.new(Protobuf::Rpc::Connectors::Base) do
-      include Protobuf::Rpc::Connectors::Common 
+      include Protobuf::Rpc::Connectors::Common
       attr_accessor :options
       attr_accessor :stats
     end
@@ -12,7 +12,7 @@ describe Protobuf::Rpc::Connectors::Common do
 
   subject{ @subject ||= common_class.new({}) }
 
-  context "API" do 
+  context "API" do
     specify{ subject.respond_to?(:any_callbacks?).should be_true }
     specify{ subject.respond_to?(:data_callback).should be_true }
     specify{ subject.respond_to?(:error).should be_true }
@@ -23,16 +23,16 @@ describe Protobuf::Rpc::Connectors::Common do
     specify{ subject.respond_to?(:verify_callbacks).should be_true }
   end
 
-  context "#any_callbacks?" do 
+  context "#any_callbacks?" do
 
     [:@complete_cb, :@success_cb, :@failure_cb].each do |cb|
-      it "returns true if #{cb} is provided" do 
+      it "returns true if #{cb} is provided" do
         subject.instance_variable_set(cb, "something")
         subject.any_callbacks?.should be_true
       end
     end
 
-    it "returns false when all callbacks are not provided" do 
+    it "returns false when all callbacks are not provided" do
       subject.instance_variable_set(:@complete_cb, nil)
       subject.instance_variable_set(:@success_cb, nil)
       subject.instance_variable_set(:@failure_cb, nil)
@@ -42,31 +42,31 @@ describe Protobuf::Rpc::Connectors::Common do
 
   end
 
-  context "#data_callback" do 
+  context "#data_callback" do
     it "changes state to use the data callback" do
       subject.data_callback("data")
       subject.instance_variable_get(:@used_data_callback).should be_true
     end
 
-    it "sets the data var when using the data_callback" do 
+    it "sets the data var when using the data_callback" do
       subject.data_callback("data")
       subject.instance_variable_get(:@data).should eq("data")
     end
   end
 
-  context "#verify_callbacks" do 
+  context "#verify_callbacks" do
 
-    it "sets @failure_cb to #data_callback when no callbacks are defined" do 
+    it "sets @failure_cb to #data_callback when no callbacks are defined" do
       subject.verify_callbacks
-      subject.instance_variable_get(:@failure_cb).should eq(subject.method(:data_callback)) 
+      subject.instance_variable_get(:@failure_cb).should eq(subject.method(:data_callback))
     end
 
     it "sets @success_cb to #data_callback when no callbacks are defined" do
       subject.verify_callbacks
-      subject.instance_variable_get(:@success_cb).should eq(subject.method(:data_callback)) 
+      subject.instance_variable_get(:@success_cb).should eq(subject.method(:data_callback))
     end
 
-    it "doesn't set @failure_cb when already defined" do 
+    it "doesn't set @failure_cb when already defined" do
       set_cb = lambda{ true }
       subject.instance_variable_set(:@failure_cb, set_cb)
       subject.verify_callbacks
@@ -74,7 +74,7 @@ describe Protobuf::Rpc::Connectors::Common do
       subject.instance_variable_get(:@failure_cb).should_not eq(subject.method(:data_callback))
     end
 
-    it "doesn't set @success_cb when already defined" do 
+    it "doesn't set @success_cb when already defined" do
       set_cb = lambda{ true }
       subject.instance_variable_set(:@success_cb, set_cb)
       subject.verify_callbacks
@@ -86,7 +86,7 @@ describe Protobuf::Rpc::Connectors::Common do
 
   shared_examples "a ConnectorDisposition" do |meth, cb, *args|
 
-    it "calls #complete before exit" do 
+    it "calls #complete before exit" do
       stats = double("Object")
       stats.stub(:end) { true }
       stats.stub(:log_stats) { true }
@@ -96,7 +96,7 @@ describe Protobuf::Rpc::Connectors::Common do
       subject.method(meth).call(*args)
     end
 
-    it "calls the #{cb} callback when provided" do 
+    it "calls the #{cb} callback when provided" do
       stats = double("Object")
       stats.stub(:end) { true }
       stats.stub(:log_stats) { true }
@@ -108,13 +108,13 @@ describe Protobuf::Rpc::Connectors::Common do
       subject.method(meth).call(*args)
     end
 
-    it "calls the complete callback when provided" do 
+    it "calls the complete callback when provided" do
       stats = double("Object")
       stats.stub(:end) { true }
       stats.stub(:log_stats) { true }
       subject.stats = stats
       comp_cb = double("Object")
-     
+
       subject.instance_variable_set(:@complete_cb, comp_cb)
       comp_cb.should_receive(:call).and_return(true)
       subject.method(meth).call(*args)