protobuf 1.0.1 → 1.1.0.beta0

data/spec/helper/all.rb

@@ -1,13 +1,7 @@
-require 'rubygems'
-require 'rspec'
-
 require 'helper/tolerance_matcher'
 require 'helper/server'
+require 'helper/silent_constants'
 
 def now
   Time.new.to_f
 end
-
-RSpec.configure do |con|
-  con.include(Sander6::CustomMatchers)
-end

data/spec/helper/server.rb

@@ -1,9 +1,11 @@
-require 'lib/protobuf/rpc/server'
+require 'ostruct'
+require 'protobuf/common/logger'
+require 'protobuf/rpc/server'
 require 'spec/proto/test_service_impl'
 
 module StubProtobufServerFactory
   def self.build(delay)
-    new_server = Class.new(Protobuf::Rpc::Server) do
+    new_server = Class.new(Protobuf::Rpc::EventedServer) do
       class << self
         def sleep_interval
           @sleep_interval
@@ -26,11 +28,49 @@ module StubProtobufServerFactory
 end
 
 class StubServer
-  def initialize(delay = 0, port = 9191)
-    @server_handle = EventMachine::start_server("127.0.0.1", port, StubProtobufServerFactory.build(delay)) 
+  include Protobuf::Logger::LogMethods
+
+  attr_accessor :options
+
+  def initialize(opts = {})
+    @running = true
+    @options = OpenStruct.new({
+        :host => "127.0.0.1", 
+        :port => 9939, 
+        :delay => 0, 
+        :server => Protobuf::Rpc::EventedServer
+      }.merge(opts))
+
+    start
+    yield self
+  ensure
+    stop if @running
+  end
+
+  def start
+    if @options.server == Protobuf::Rpc::EventedServer
+      start_em_server
+    else
+      Protobuf::Rpc::SocketRunner.run(@options)
+    end
+    log_debug "[stub-server] Server started #{@options.host}:#{@options.port}"
+  rescue => ex
+    if ex =~ /no acceptor/ # Means EM didn't shutdown in the next_tick yet
+      stop
+      retry
+    end
+  end
+
+  def start_em_server
+    @server_handle = EventMachine::start_server(@options.host, @options.port, StubProtobufServerFactory.build(@options.delay))
   end
 
   def stop
-    EventMachine.stop_server(@server_handle)
+    if @options.server == Protobuf::Rpc::EventedServer
+      EventMachine.stop_server(@server_handle)
+    else
+      Protobuf::Rpc::SocketRunner.stop
+    end
+    @running = false
   end
 end

data/spec/helper/silent_constants.rb

@@ -0,0 +1,40 @@
+# Just a way to keep warnings from being flagged in rename of constants during tests
+module Kernel
+  def silence_warnings
+    orig_verbosity = $VERBOSE
+    $VERBOSE = nil
+    yield
+    $VERBOSE = orig_verbosity
+  end
+end
+
+module SilentConstants
+  def parse(constant)
+    source, _, constant_name = constant.to_s.rpartition('::')
+    [Object.const_get(source.to_sym), constant_name.to_sym]
+  end
+
+  # Examples
+  # with_constants "Something" => "nothing" do 
+  # end
+  #
+  # with_constants "Something::Foo" => "something else" do 
+  # end
+  #
+  def with_constants(constants, &block)
+    saved_constants = {}
+    constants.each do |constant, val|
+      source_object, const_name = parse(constant)
+      saved_constants[constant] = source_object.const_get(const_name)
+      Kernel::silence_warnings { source_object.const_set(const_name, val) }
+    end
+
+    block.call
+  ensure
+    constants.each do |constant, val|
+      source_object, const_name = parse(constant)
+      Kernel::silence_warnings { source_object.const_set(const_name, saved_constants[constant]) }
+    end
+  end
+
+end

data/spec/proto/test_service.rb

@@ -1,5 +1,4 @@
 require 'protobuf/rpc/service'
-require 'spec/proto/test.pb'
 
 ##	!! DO NOT EDIT THIS FILE !!
 ## 

data/spec/proto/test_service_impl.rb

@@ -1,9 +1,10 @@
-require 'spec/proto/test_service'
+require 'protobuf/rpc/service'
+require File.dirname(__FILE__) + '/test.pb'
+require File.dirname(__FILE__) + '/test_service'
 
 module Spec
   module Proto
     class TestService
-      located_at "localhost:9191"
     
       # request -> Spec::Proto::ResourceFindRequest
       # response -> Spec::Proto::Resource
@@ -14,4 +15,4 @@ module Spec
     
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,16 +1,29 @@
+require 'simplecov'
+SimpleCov.start
+
 require 'rubygems'
 require 'bundler'
 Bundler.setup :default, :development, :test
 
-RSpec.configure do |c|
-  c.mock_with :rspec
-end
-
 $:.push File.expand_path('..', File.dirname(__FILE__))
 $:.push File.expand_path('../lib', File.dirname(__FILE__))
-require 'protobuf'
 
+require 'protobuf'
 require 'protobuf/rpc/client'
+require File.dirname(__FILE__) + '/helper/all'
+
+# Including a way to turn on debug logger for spec runs
+if ENV["DEBUG"]
+  debug_log = File.expand_path('../debug_specs.log', File.dirname(__FILE__) )
+  Protobuf::Logger.configure(:file => debug_log, :level => ::Logger::DEBUG)
+end
+
+RSpec.configure do |c|
+  c.include(SilentConstants)
+  c.include(Sander6::CustomMatchers)
+  c.mock_with :rspec
+end
+
 class ::Protobuf::Rpc::Client
   def == other
    connector.options == other.options && \
@@ -21,4 +34,4 @@ end
 
 def reset_service_location service
   service.instance_variable_set :@locations, nil
-end
+end

data/spec/unit/enum_spec.rb

@@ -4,10 +4,10 @@ require 'spec/proto/test.pb'
 describe Protobuf::Enum do
   context 'when coercing from enum' do
     subject { Spec::Proto::StatusType::PENDING }
-    it { should == 0 }
+    it { should eq(0) }
   end
+
   context 'when coercing from integer' do
-    subject { 0 }
-    it { should == Spec::Proto::StatusType::PENDING }
+    it { 0.should eq(Spec::Proto::StatusType::PENDING) }
   end
-end
+end

data/spec/unit/rpc/client_spec.rb

@@ -1,61 +1,53 @@
 require 'spec_helper'
 require 'spec/proto/test_service_impl'
-require 'spec/helper/all'
 
 describe Protobuf::Rpc::Client do
 
   context "when using fiber based calls" do
     it "waits for response when running synchronously" do
       EventMachine.fiber_run do
-        delay = 3
-        server = StubServer.new(delay)
-        stop_servers = lambda { server.stop; EventMachine.stop }
-        client = Spec::Proto::TestService.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) 
+        StubServer.new(:delay => 3) do |server|
+          client = Spec::Proto::TestService.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) 
+            end 
+
+            c.on_failure do |err|
+              raise err.inspect
+            end
           end
 
-          c.on_failure do |err|
-            raise err.inspect
-          end
+          (now - start).should be_within(server.options.delay * 0.10).of(server.options.delay)
         end
 
-        (now - start).should be_within(delay * 0.10).of(delay)
-        stop_servers.call
+        EM.stop
       end
     end
 
     it "doesn't wait for response when running async call inside fiber" do
       EventMachine.fiber_run do
-        delay = 3
-        server = StubServer.new(delay)
-        stop_servers = lambda { server.stop; EventMachine.stop }
-        client = Spec::Proto::TestService.client(:async => true)
-
-        start = now
-        
-        client.find(:name => "Test Name", :active => true)
+        StubServer.new(:delay => 3) do |server|
+          client = Spec::Proto::TestService.client(:async => true)
+          start = now
+          client.find(:name => "Test Name", :active => true)
 
-        (now - start).should_not be_within(delay * 0.10).of(delay)
-        stop_servers.call
+          (now - start).should_not be_within(server.options.delay* 0.10).of(server.options.delay)
+        end
+        EM.stop
       end
     end
 
     it "throws and error when synchronous code is attempted without 'EventMachine.fiber_run'" do
       subject = Proc.new do
         EventMachine.run do
-          delay = 1
-          server = StubServer.new(delay)
-          stop_servers = lambda { server.stop; EventMachine.stop }
-          client = Spec::Proto::TestService.client(:async => false)
-
-          client.find(:name => "Test Name", :active => true)
-          stop_servers.call
+          StubServer.new(:delay => 1) do |server|
+            client = Spec::Proto::TestService.client(:async => false)
+            client.find(:name => "Test Name", :active => true)
+          end
         end
       end
 
@@ -65,13 +57,11 @@ describe Protobuf::Rpc::Client do
     it "throws a timeout when client timeout is exceeded" do
       subject = Proc.new do
         EventMachine.fiber_run do
-          delay = 3
-          server = StubServer.new(delay)
-          stop_servers = lambda { server.stop; EventMachine.stop }
-          client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
-
-          client.find(:name => "Test Name", :active => true)
-          stop_servers.call
+          StubServer.new(:delay => 2) do |server|
+            client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
+            client.find(:name => "Test Name", :active => true)
+          end
+          EM.stop
         end
       end
 
@@ -164,7 +154,7 @@ describe Protobuf::Rpc::Client do
       client = Spec::Proto::TestService.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(Spec::Proto::ResourceFindRequest)
       client.options[:request].name.should eq('Test Name')
       client.options[:request].active.should eq(false)
     end

data/spec/unit/rpc/connector_spec.rb

@@ -2,32 +2,27 @@ require 'spec_helper'
 
 describe Protobuf::Rpc::Connector do
   
-  describe '.connector_for_platform' do
+  describe '.connector_for_client' do
     
-    context 'when platform is java' do
-      let(:platform) { 'jruby' }
+    context 'when set to Socket connector' do
       it 'returns a socket connector class reference' do
-        Protobuf::Rpc::Connector.connector_for_platform(platform).should eq Protobuf::Rpc::Connectors::Socket
+        with_constants "Protobuf::ConnectorType" => "Socket" do
+          Protobuf::Rpc::Connector.connector_for_client.should eq(Protobuf::Rpc::Connectors::Socket)
+        end
       end
     end
   
-    context 'when platform is mri' do
-      let(:platform) { 'mri' }
+    context 'when set to non Socket Connector' do
       it 'returns an eventmachine connector class reference' do
-        Protobuf::Rpc::Connector.connector_for_platform(platform).should eq Protobuf::Rpc::Connectors::EventMachine
+        with_constants "Protobuf::ConnectorType" => "EventMachine" do 
+          Protobuf::Rpc::Connector.connector_for_client.should eq Protobuf::Rpc::Connectors::EventMachine
+        end
       end
     end
   
-    context 'when platform is unknown' do
-      let(:platform) { 'some_bogus_engine' }
+    context 'when connector type not given' do
       it 'returns an eventmachine connector class reference' do
-        Protobuf::Rpc::Connector.connector_for_platform(platform).should eq Protobuf::Rpc::Connectors::EventMachine
-      end
-    end
-  
-    context 'when platform is not given' do
-      it 'returns an eventmachine connector class reference' do
-        Protobuf::Rpc::Connector.connector_for_platform.should eq Protobuf::Rpc::Connectors::EventMachine
+        Protobuf::Rpc::Connector.connector_for_client.should eq Protobuf::Rpc::Connectors::EventMachine
       end
     end
   

data/spec/unit/rpc/connectors/base_spec.rb

@@ -8,9 +8,20 @@ describe Protobuf::Rpc::Connectors::Base do
   
   subject { Protobuf::Rpc::Connectors::Base.new(opts) }
   
+  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 
+      new_sub = Class.new(subject.class){ def send_request; end }.new(opts)
+      expect{ new_sub.send_request }.to_not raise_error
+    end
+  end
+
   describe '.new' do
     it 'assigns passed options and initializes success/failure callbacks' do
-      subject.options.should eq opts
+      subject.options.should eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(opts))
       subject.success_cb.should be_nil
       subject.failure_cb.should be_nil
     end
@@ -21,7 +32,7 @@ describe Protobuf::Rpc::Connectors::Base do
       subject.success_cb.should be_nil
       cb = proc {|res| raise res }
       subject.success_cb = cb
-      subject.success_cb.should eq cb
+      subject.success_cb.should eq(cb)
       expect { subject.success_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end
@@ -31,7 +42,7 @@ describe Protobuf::Rpc::Connectors::Base do
       subject.failure_cb.should be_nil
       cb = proc {|res| raise res }
       subject.failure_cb = cb
-      subject.failure_cb.should eq cb
+      subject.failure_cb.should eq(cb)
       expect { subject.failure_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end

data/spec/unit/rpc/connectors/common_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper' 
+require 'protobuf/rpc/service' 
+
+describe Protobuf::Rpc::Connectors::Common do
+  let(:common_class) do 
+    Class.new(Protobuf::Rpc::Connectors::Base) do
+      include Protobuf::Rpc::Connectors::Common 
+      attr_accessor :options
+      attr_accessor :stats
+    end
+  end
+
+  subject{ @subject ||= common_class.new({}) }
+
+  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 }
+    specify{ subject.respond_to?(:fail).should be_true }
+    specify{ subject.respond_to?(:complete).should be_true }
+    specify{ subject.respond_to?(:parse_response).should be_true }
+    specify{ subject.respond_to?(:_send_request).should be_true }
+    specify{ subject.respond_to?(:verify_options).should be_true }
+    specify{ subject.respond_to?(:verify_callbacks).should be_true }
+  end
+
+  context "#any_callbacks?" do 
+
+    [:@complete_cb, :@success_cb, :@failure_cb].each do |cb|
+      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 
+      subject.instance_variable_set(:@complete_cb, nil)
+      subject.instance_variable_set(:@success_cb, nil)
+      subject.instance_variable_set(:@failure_cb, nil)
+
+      subject.any_callbacks?.should be_false
+    end
+
+  end
+
+  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 
+      subject.data_callback("data")
+      subject.instance_variable_get(:@data).should eq("data")
+    end
+  end
+
+  context "#verify_callbacks" 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)) 
+    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)) 
+    end
+
+    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
+      subject.instance_variable_get(:@failure_cb).should eq(set_cb)
+      subject.instance_variable_get(:@failure_cb).should_not eq(subject.method(:data_callback))
+    end
+
+    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
+      subject.instance_variable_get(:@success_cb).should eq(set_cb)
+      subject.instance_variable_get(:@success_cb).should_not eq(subject.method(:data_callback))
+    end
+
+  end
+
+  shared_examples "a ConnectorDisposition" do |meth, cb, *args|
+
+    it "calls #complete before exit" do 
+      stats = double("Object")
+      stats.stub(:end) { true }
+      stats.stub(:log_stats) { true }
+      subject.stats = stats
+
+      subject.should_receive(:complete)
+      subject.method(meth).call(*args)
+    end
+
+    it "calls the #{cb} callback when provided" do 
+      stats = double("Object")
+      stats.stub(:end) { true }
+      stats.stub(:log_stats) { true }
+      subject.stats = stats
+      _cb = double("Object")
+
+      subject.instance_variable_set("@#{cb}", _cb)
+      _cb.should_receive(:call).and_return(true)
+      subject.method(meth).call(*args)
+    end
+
+    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)
+    end
+
+  end
+
+  it_behaves_like("a ConnectorDisposition", :fail, "failure_cb", "code", "message")
+  it_behaves_like("a ConnectorDisposition", :fail, "complete_cb", "code", "message")
+  it_behaves_like("a ConnectorDisposition", :succeed, "complete_cb", "response")
+  it_behaves_like("a ConnectorDisposition", :succeed, "success_cb", "response")
+  it_behaves_like("a ConnectorDisposition", :complete, "complete_cb")
+
+end