protobuf 1.1.3 → 1.3.0

data/spec/functional/evented_server_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'spec/proto/test_service_impl'
+
+describe 'Functional EventMachine Client' do
+  before(:each) do
+    ::Spec::Proto::TestService.configure(::Spec::Proto::TestService::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.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
+        end
+        EM.stop
+      end
+    }.to_not raise_error
+  end
+
+  it 'calls the on_failure callback when a message is malformed' 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)
+
+        client.find(request) do |c|
+          c.on_success { raise "shouldn't pass"}
+          c.on_failure {|e| error = e}
+        end
+      end
+      EM.stop
+    end
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set.*"name"/
+  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)
+
+        client.find(request) do |c|
+          c.on_success { raise "shouldn't pass"}
+          c.on_failure {|e| error = e}
+        end
+      end
+      EM.stop
+    end
+    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
+  end
+end

data/spec/functional/socket_server_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'spec/proto/test_service_impl'
+
+describe 'Functional Socket Client' do
+  before(:all) do
+    Thread.abort_on_exception = true
+    server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    @server_thread = Thread.new(server) { |s| Protobuf::Rpc::SocketRunner.run(s) }
+    Thread.pass until Protobuf::Rpc::Socket::Server.running?
+  end
+
+  after(:all) do
+    Protobuf::Rpc::SocketRunner.stop
+    @server_thread.join
+  end
+
+  it 'runs fine when required fields are set' do
+    expect {
+      with_constants "Protobuf::ClientType" => "Socket" do
+        client = ::Spec::Proto::TestService.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)
+          end
+
+          c.on_failure do |err|
+            raise err.inspect
+          end
+        end
+      end
+    }.to_not raise_error
+  end
+
+  it 'calls the on_failure callback when a message is malformed' do
+    error = nil
+    with_constants "Protobuf::ClientType" => "Socket" do
+      request = ::Spec::Proto::ResourceFindRequest.new(:active => true)
+      client = ::Spec::Proto::TestService.client(:async => false)
+
+      client.find(request) do |c|
+        c.on_success { raise "shouldn't pass"}
+        c.on_failure {|e| error = e}
+      end
+    end
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set.*"name"/
+  end
+
+  it 'calls the on_failure callback when the request type is wrong' do
+    error = nil
+    with_constants "Protobuf::ClientType" => "Socket" do
+      request = ::Spec::Proto::Resource.new(:name => 'Test Name')
+      client = ::Spec::Proto::TestService.client(:async => false)
+
+      client.find(request) do |c|
+        c.on_success { raise "shouldn't pass"}
+        c.on_failure {|e| error = e}
+      end
+    end
+    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
+  end
+end

data/spec/functional/zmq_server_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'spec/proto/test_service_impl'
+
+describe 'Functional ZMQ Client' do
+  before(:all) do
+    Thread.abort_on_exception = true
+    server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    @server_thread = Thread.new(server) { |s| Protobuf::Rpc::ZmqRunner.run(s) }
+    Thread.pass until Protobuf::Rpc::Zmq::Server.running?
+  end
+
+  after(:all) do
+    ::Protobuf::Rpc::Zmq::Server.stop
+    @server_thread.join
+  end
+
+  it 'runs fine when required fields are set' do
+    expect {
+      with_constants "Protobuf::ClientType" => "Zmq" do
+        client = ::Spec::Proto::TestService.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)
+          end
+
+          c.on_failure do |err|
+            raise err.inspect
+          end
+        end
+      end
+    }.to_not raise_error
+  end
+
+  it 'calls the on_failure callback when a message is malformed' do
+    error = nil
+    with_constants "Protobuf::ClientType" => "Zmq" do
+      request = ::Spec::Proto::ResourceFindRequest.new(:active => true)
+      client = ::Spec::Proto::TestService.client(:async => false)
+
+      client.find(request) do |c|
+        c.on_success { raise "shouldn't pass"}
+        c.on_failure {|e| error = e}
+      end
+    end
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set.*"name"/
+  end
+
+  it 'calls the on_failure callback when the request type is wrong' do
+    error = nil
+    with_constants "Protobuf::ClientType" => "Zmq" do
+      request = ::Spec::Proto::Resource.new(:name => 'Test Name')
+      client = ::Spec::Proto::TestService.client(:async => false)
+
+      client.find(request) do |c|
+        c.on_success { raise "shouldn't pass"}
+        c.on_failure {|e| error = e}
+      end
+    end
+    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
+  end
+end

data/spec/helper/server.rb

@@ -1,13 +1,18 @@
 require 'ostruct'
 require 'protobuf/common/logger'
 require 'protobuf/rpc/server'
-require 'protobuf/rpc/servers/socket_server'
+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'
 
+# Want to abort if server dies?
+Thread.abort_on_exception = true
+
 module StubProtobufServerFactory
   def self.build(delay)
-    new_server = Class.new(Protobuf::Rpc::EventedServer) do
+    new_server = Class.new(Protobuf::Rpc::Evented::Server) do
       def self.sleep_interval
         @sleep_interval
       end
@@ -38,7 +43,7 @@ class StubServer
         :host => "127.0.0.1", 
         :port => 9399, 
         :delay => 0, 
-        :server => Protobuf::Rpc::EventedServer
+        :server => Protobuf::Rpc::Evented::Server
       }.merge(opts))
 
     start
@@ -48,14 +53,13 @@ class StubServer
   end
 
   def start
-    if @options.server == Protobuf::Rpc::EventedServer
-      start_em_server
+    case
+    when @options.server == Protobuf::Rpc::Evented::Server then start_em_server
+    when @options.server == Protobuf::Rpc::Zmq::Server then start_zmq_server
     else
-      @sock_server = Thread.new(@options) { |opt| Protobuf::Rpc::SocketRunner.run(opt) }
-      @sock_server.abort_on_exception = true # Set for testing purposes
-      Thread.pass until Protobuf::Rpc::SocketServer.running?
+      start_socket_server
     end
-    log_debug "[stub-server] Server started #{@options.host}:#{@options.port}"
+    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
@@ -64,16 +68,32 @@ class StubServer
   end
 
   def start_em_server
-    @server_handle = EventMachine::start_server(@options.host, @options.port, StubProtobufServerFactory.build(@options.delay))
+    @server_handle = EventMachine.start_server(@options.host, @options.port, StubProtobufServerFactory.build(@options.delay))
+  end
+
+  def start_socket_server
+    @sock_server = Thread.new(@options) { |opt| Protobuf::Rpc::SocketRunner.run(opt) }
+    @sock_server.abort_on_exception = true # Set for testing purposes
+    Thread.pass until Protobuf::Rpc::Socket::Server.running?
+  end
+
+  def start_zmq_server
+    @zmq_server = Thread.new(@options) { |opt| Protobuf::Rpc::ZmqRunner.run(opt) }    
+    Thread.pass until Protobuf::Rpc::Zmq::Server.running?
   end
 
   def stop
-    if @options.server == Protobuf::Rpc::EventedServer
+    case
+    when @options.server == Protobuf::Rpc::Evented::Server then
       EventMachine.stop_server(@server_handle) if @server_handle
+    when @options.server == Protobuf::Rpc::Zmq::Server then
+      Protobuf::Rpc::ZmqRunner.stop
+      @zmq_server.join if(@zmq_server)
     else
       Protobuf::Rpc::SocketRunner.stop
-      Thread.kill(@sock_server) if @sock_server
+      @sock_server.join if(@sock_server)
     end
+
     @running = false
   end
 end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+class EncoderTest
+  extend ::Protobuf::Encoder
+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(:stream) { StringIO.new }
+      it "raises a 'message not initialized' error" do
+        expect {
+          EncoderTest.__send__(:encode, stream, message)
+        }.to raise_error(Protobuf::NotInitializedError, /message.*not initialized/i)
+      end
+    end
+  end
+end

data/spec/proto/test.pb.rb

@@ -12,11 +12,11 @@ module Spec
       define :DELETED, 3
     end
     class ResourceFindRequest < ::Protobuf::Message
-      optional :string, :name, 1
+      required :string, :name, 1
       optional :bool, :active, 2
     end
     class Resource < ::Protobuf::Message
-      optional :string, :name, 1
+      required :string, :name, 1
       optional :int64, :date_created, 2
       optional :StatusType, :status, 3
       repeated :StatusType, :repeated_enum, 4
@@ -28,4 +28,4 @@ module Spec
       optional :StatusType, :status, 4
     end
   end
-end
+end

data/spec/proto/test.proto

@@ -8,12 +8,12 @@ enum StatusType {
 }
 
 message ResourceFindRequest {
-  optional string name = 1;
+  required string name = 1;
   optional bool active = 2;
 }
 
 message Resource {
-  optional string name = 1;
+  required string name = 1;
   optional int64 date_created = 2;
   optional StatusType status = 3;
   repeated StatusType repeated_enum = 4;
@@ -28,4 +28,4 @@ message Nested {
 
 service TestService {
   rpc Find (ResourceFindRequest) returns (Resource);
-}
+}

data/spec/proto/test_service.rb

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

data/spec/spec_helper.rb

@@ -11,6 +11,12 @@ $:.push File.expand_path('../lib', File.dirname(__FILE__))
 require 'protobuf'
 require 'protobuf/rpc/client'
 require File.dirname(__FILE__) + '/helper/all'
+require 'pry'
+
+# these aren't explicitly required in lib/protobuf.rb. We require them here for
+# testing purposes
+require 'ffi-rzmq'
+require 'protobuf/rpc/connectors/zmq'
 
 # Including a way to turn on debug logger for spec runs
 if ENV["DEBUG"]

data/spec/unit/message_spec.rb

@@ -64,4 +64,4 @@ describe Protobuf::Message do
     
   end
   
-end
+end

data/spec/unit/rpc/client_spec.rb

@@ -2,6 +2,9 @@ require 'spec_helper'
 require 'spec/proto/test_service_impl'
 
 describe Protobuf::Rpc::Client do
+  before(:each) do
+    ::Spec::Proto::TestService.configure(::Spec::Proto::TestService::DEFAULT_LOCATION)
+  end
 
   context "when using fiber based calls" do
     it "waits for response when running synchronously" do
@@ -55,17 +58,22 @@ describe Protobuf::Rpc::Client do
     end
 
     it "throws a timeout when client timeout is exceeded" do
-      subject = Proc.new do
+      error = nil
+      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.find(:name => "Test Name", :active => true)
+            client.find(:name => "Test Name", :active => true) do |cl|
+              cl.on_success {}
+              cl.on_failure {|f| error = f}
+            end
           end
           EM.stop
         end
       end
 
-      subject.should raise_error(RuntimeError, /timeout/i)
+      test_proc.call
+      error.message.should =~ /timeout/i
     end
 
     context "without reactor_running?" do 

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

@@ -19,7 +19,6 @@ describe Protobuf::Rpc::Connectors::Common do
     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

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ::Protobuf::Rpc::Connectors::EMClient do
+  describe '#send_data' do
+    context 'when sending data errs' do
+      let(:buffer_double) do
+        bd = double(Protobuf::Rpc::Buffer)
+        bd.should_receive(:set_data)
+        bd
+      end
+
+      it 'sets the error instance' do
+        buffer_double.should_receive(:write).and_raise(RuntimeError.new('Failure for testing'))
+        Protobuf::Rpc::Buffer.stub(:new).with(:read).and_return(Protobuf::Rpc::Buffer.new(:read))
+        Protobuf::Rpc::Buffer.stub(:new).with(:write).and_return(buffer_double)
+        error = nil
+        test_proc = Proc.new do
+          StubServer.new do |server|
+            client = ::Spec::Proto::TestService.client
+            client.find(:name => 'Test Name', :active => true) do |c|
+              c.on_failure do |f|
+                error = f
+              end
+            end
+          end
+        end
+        test_proc.call
+        error.should_not be_nil
+      end
+    end
+  end
+end

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

@@ -24,13 +24,12 @@ describe Protobuf::Rpc::Connectors::Socket do
 
     it "fills the buffer with data from the socket" do 
       socket = StringIO.new("#{data.bytesize}-#{data}")
-      subject.instance_variable_set(:@buffer, Protobuf::Rpc::Buffer.new(:read))
       subject.instance_variable_set(:@socket, socket)
+      subject.instance_variable_set(:@stats, OpenStruct.new)
       subject.should_receive(:parse_response).and_return(true)
 
       subject.__send__(:read_response)
-      subject.instance_variable_get(:@buffer).flushed?.should be_true
-      subject.instance_variable_get(:@buffer).data.should eq(data)
+      subject.instance_variable_get(:@response_data).should eq(data)
     end
   end
 
@@ -45,5 +44,4 @@ describe Protobuf::Rpc::Connectors::Socket do
       expect{ conn.__send__(:check_async) }.to_not raise_error
     end
   end
-
 end