protobuf 2.2.5-java

data/spec/lib/protobuf/message_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+
+describe Protobuf::Message do
+
+  describe '#initialize' do 
+    it "does not try to set attributes which have nil values" do 
+      Test::EnumTestMessage.any_instance.should_not_receive("non_default_enum=")
+      test_enum = Test::EnumTestMessage.new(:non_default_enum => nil)
+    end
+
+    it "takes a hash as an initialization argument" do 
+      test_enum = Test::EnumTestMessage.new(:non_default_enum => 2)
+      test_enum.non_default_enum.should eq(2)
+    end
+
+    it "initializes with an object that responds to #to_hash" do 
+      hashie_object = OpenStruct.new(:to_hash => { :non_default_enum => 2 })      
+      test_enum = Test::EnumTestMessage.new(hashie_object)
+      test_enum.non_default_enum.should eq(2)
+    end
+  end
+
+  describe "boolean predicate methods" do 
+    subject { Test::ResourceFindRequest.new(:name => "resource") }
+
+    it { should respond_to(:active?) }
+
+    it "sets the predicate to true when the boolean value is true" do 
+      subject.active = true
+      subject.active?.should be_true
+    end
+
+    it "sets the predicate to false when the boolean value is false" do 
+      subject.active = false
+      subject.active?.should be_false
+    end
+
+    it "does not put predicate methods on non-boolean fields" do 
+      Test::ResourceFindRequest.new(:name => "resource").should_not respond_to(:name?)
+    end
+  end
+
+  describe "#respond_to_and_has?" do 
+    subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+    it "is false when the message does not have the field" do 
+      subject.respond_to_and_has?(:other_field).should be_false
+    end
+
+    it "is true when the message has the field" do 
+      subject.respond_to_and_has?(:non_default_enum).should be_true
+    end
+  end
+
+  describe "#respond_to_has_and_present?" do 
+    subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+    it "is false when the message does not have the field" do 
+      subject.respond_to_and_has_and_present?(:other_field).should be_false
+    end
+
+    it "is false when the field is repeated and a value is not present" do 
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+    end
+
+    it "is false when the field is repeated and the value is empty array" do 
+      subject.repeated_enums = []
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+    end
+
+    it "is true when the field is repeated and a value is present" do 
+      subject.repeated_enums = [2]
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_true
+    end
+
+    it "is true when the message has the field" do 
+      subject.respond_to_and_has_and_present?(:non_default_enum).should be_true
+    end
+
+    context "#API" do 
+      subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+        
+      it { should respond_to(:respond_to_and_has_and_present?) }
+      it { should respond_to(:responds_to_and_has_and_present?) }
+      it { should respond_to(:responds_to_has?) }
+      it { should respond_to(:respond_to_has?) }
+      it { should respond_to(:respond_to_has_present?) }
+      it { should respond_to(:responds_to_has_present?) }
+      it { should respond_to(:respond_to_and_has_present?) }
+      it { should respond_to(:responds_to_and_has_present?) }
+    end
+   
+  end
+
+  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
+
+  describe '#get_field_by_name' do
+    subject do
+      ::Test::Resource.new({ :name => 'Test Name', :date_created => Time.now.to_i })
+    end
+
+    context 'when name is a valid field' do
+      let(:valid_field) { subject.get_field_by_name(:name) }
+      specify { valid_field.should be_a ::Protobuf::Field::StringField }
+      specify { valid_field.name.should eq :name }
+    end
+
+    context 'when name is not a valid field' do
+      specify do
+        expect {
+          subject.get_field_by_name(1)
+        }.to raise_error(::Protobuf::Message::FieldNotDefinedError, /.*1.*#{subject.class.name}/)
+      end
+
+      specify do
+        expect {
+          subject.get_field_by_name(:nothere)
+        }.to raise_error(::Protobuf::Message::FieldNotDefinedError, /.*nothere.*#{subject.class.name}/)
+      end
+
+      specify do
+        expect {
+          subject.get_field_by_name(nil)
+        }.to raise_error(::Protobuf::Message::FieldNotDefinedError, /.*nil.*#{subject.class.name}/)
+      end
+    end
+  end
+
+  describe '#get_ext_field_by_name' do
+    pending 'Need to get a proto compiled with extensions first'
+  end
+
+  describe '#get_field_by_tag' do
+    subject do
+      ::Test::Resource.new({ :name => 'Test Name', :date_created => Time.now.to_i })
+    end
+
+    context 'when tag references a valid field' do
+      let(:valid_field) { subject.get_field_by_tag(1) }
+      specify { valid_field.should be_a ::Protobuf::Field::StringField }
+      specify { valid_field.name.should eq :name }
+    end
+
+    context 'when tag does not reference a field' do
+      it 'returns nil' do
+        pending 'need to implement a range-limiting array sub-class for field access'
+        subject.get_field_by_tag(-1).should be_nil
+      end
+    end
+
+    context 'when tag is not numeric' do
+      specify do
+        expect {
+          subject.get_field_by_tag("not a number")
+        }.to raise_error(::Protobuf::Message::FieldNotDefinedError, /.*not a number.*#{subject.class.name}/)
+      end
+
+      specify do
+        expect {
+          subject.get_field_by_tag(nil)
+        }.to raise_error(::Protobuf::Message::FieldNotDefinedError, /.*nil.*#{subject.class.name}/)
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+describe Protobuf::Rpc::Client do
+  before(:each) do
+    load 'protobuf/evented.rb'
+  end
+
+  context "when using fiber based calls" do
+    it "waits for response" do
+      EventMachine.fiber_run do
+        StubServer.new(:delay => 3) do |server|
+          client = Test::ResourceService.client
+          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(Test::StatusType::ENABLED)
+            end
+
+            c.on_failure do |err|
+              raise err.inspect
+            end
+          end
+
+          (now - start).should be_within(server.options.delay * 0.10).of(server.options.delay)
+        end
+
+        EM.stop
+      end
+    end
+
+    it "throws and error when call is attempted without 'EventMachine.fiber_run'" do
+      subject = Proc.new do
+        EventMachine.run do
+          StubServer.new(:delay => 1) do |server|
+            client = Test::ResourceService.client
+            client.find(:name => "Test Name", :active => true)
+          end
+        end
+      end
+
+      subject.should raise_error(RuntimeError, /EM.fiber_run/)
+    end
+
+    it "throws a timeout when client timeout is exceeded" do
+      error = nil
+      test_proc = Proc.new do
+        EventMachine.fiber_run do
+          StubServer.new(:delay => 2) do |server|
+            client = Test::ResourceService.client(:timeout => 1)
+            client.find(:name => "Test Name", :active => true) do |cl|
+              cl.on_success {}
+              cl.on_failure {|f| error = f}
+            end
+          end
+          EM.stop
+        end
+      end
+
+      test_proc.call
+      error.message.should =~ /timeout/i
+    end
+
+    context "without reactor_running?" do
+
+      it "throws a timeout when client timeout is exceeded" do
+        subject = Proc.new do
+          StubServer.new(:delay => 2) do |server|
+            client = Test::ResourceService.client(:timeout => 1)
+            client.find(:name => "Test Name", :active => true)
+          end
+        end
+
+        subject.should raise_error(RuntimeError, /timeout/i)
+      end
+
+      it "calls failure_cb & throws a timeout when client timeout is exceeded" do
+        failure_message = nil
+
+        subject = Proc.new do
+          StubServer.new(:delay => 2) do |server|
+            client = Test::ResourceService.client(:timeout => 1)
+            client.find(:name => "Test Name", :active => true) do |c|
+              c.on_failure do |f|
+                failure_message = f.message
+              end
+            end
+          end
+        end
+
+        subject.call
+        failure_message.should match(/timeout/)
+      end
+
+    end
+
+  end
+
+  context 'when creating a client from a service' do
+    before { reset_service_location(Test::ResourceService) }
+
+    it 'should be able to get a client through the Service#client helper method' do
+      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
+      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 = 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 which service to create itself for' do
+      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
+      client = Test::ResourceService.client
+      client.options[:host].should eq(Protobuf::Rpc::Service::DEFAULT_HOST)
+      client.options[:port].should eq(Protobuf::Rpc::Service::DEFAULT_PORT)
+    end
+
+  end
+
+  context 'when calling methods on a service client' do
+
+    # NOTE: we are assuming the service methods are accurately
+    # defined inside spec/proto/test_service.rb,
+    # namely the :find method
+
+    it 'should respond to defined service methods' do
+      client = Test::ResourceService.client
+      client.should_receive(:send_request).and_return(nil)
+      expect { client.find(nil) }.to_not raise_error
+    end
+  end
+
+  context 'when receiving request objects' do
+
+    it 'should be able to create the correct request object if passed a hash' do
+      client = Test::ResourceService.client
+      client.should_receive(:send_request)
+      client.find({:name => 'Test Name', :active => false})
+      client.options[:request].should be_a(Test::ResourceFindRequest)
+      client.options[:request].name.should eq('Test Name')
+      client.options[:request].active.should eq(false)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'protobuf/socket'
+require 'protobuf/evented'
+require 'protobuf/zmq'
+
+describe ::Protobuf::Rpc::Connector do
+
+  describe '.connector_for_client(true)' do
+    subject { described_class.connector_for_client }
+
+    context 'Protobuf.connector_type is socket' do
+      before { ::Protobuf.connector_type = :socket }
+      it { should eq ::Protobuf::Rpc::Connectors::Socket }
+    end
+
+    context 'Protobuf.connector_type is not a known value' do
+      before { ::Protobuf.connector_type = :socket }
+      it { should eq ::Protobuf::Rpc::Connectors::Socket }
+    end
+
+    context 'Protobuf.connector_type is evented' do
+      before { ::Protobuf.connector_type = :evented }
+      it { should eq ::Protobuf::Rpc::Connectors::EventMachine }
+    end
+
+    context 'Protobuf.connector_type is zmq' do
+      before { ::Protobuf.connector_type = :zmq }
+      it { should eq ::Protobuf::Rpc::Connectors::Zmq }
+    end
+  end
+
+end

data/spec/lib/protobuf/rpc/connectors/base_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Protobuf::Rpc::Connectors::Base do
+
+  let(:options) do
+    { :timeout => 60 }
+  end
+
+  subject { Protobuf::Rpc::Connectors::Base.new(options) }
+
+  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(options)
+      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(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(options))
+      subject.success_cb.should be_nil
+      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
+      cb = proc {|res| raise res }
+      subject.success_cb = 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
+
+  describe '#failure_cb' do
+    it 'allows setting the failure callback and calling it' do
+      subject.failure_cb.should be_nil
+      cb = proc {|res| raise res }
+      subject.failure_cb = 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
+
+end

data/spec/lib/protobuf/rpc/connectors/common_spec.rb

@@ -0,0 +1,128 @@
+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?(: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(:stop) { 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(:stop) { 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(:stop) { 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

data/spec/lib/protobuf/rpc/connectors/socket_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'protobuf/socket'
+
+shared_examples "a Protobuf Connector" do
+  subject{ described_class.new({}) }
+
+  context "API" do
+    # Check the API
+    specify{ subject.respond_to?(:send_request, true).should be_true }
+    specify{ subject.respond_to?(:post_init, true).should be_true }
+    specify{ subject.respond_to?(:close_connection, true).should be_true }
+    specify{ subject.respond_to?(:error?, true).should be_true }
+  end
+end
+
+describe Protobuf::Rpc::Connectors::Socket do
+  subject{ described_class.new({}) }
+
+  it_behaves_like "a Protobuf Connector"
+
+  specify{ described_class.include?(Protobuf::Rpc::Connectors::Common).should be_true }
+
+  context "#read_response" do
+    let(:data){ "New data" }
+
+    it "fills the buffer with data from the socket" do
+      socket = StringIO.new("#{data.bytesize}-#{data}")
+      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(:@response_data).should eq(data)
+    end
+  end
+end

data/spec/lib/protobuf/rpc/connectors/zmq_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'protobuf/zmq'
+
+describe ::Protobuf::Rpc::Connectors::Zmq do
+  let(:socket_mock) do
+    sm = mock(::ZMQ::Socket)
+    sm.stub(:connect).and_return(0)
+    sm
+  end
+
+  let(:zmq_context_mock) do
+    zc = mock(::ZMQ::Context)
+    zc.stub(:socket).and_return(socket_mock)
+    zc
+  end
+
+  before(:each) do
+    ::ZMQ::Context.stub(:new).and_return(zmq_context_mock)
+  end
+
+  pending
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+require 'protobuf/rpc/servers/evented_runner'
+require 'protobuf/evented'
+
+describe Protobuf::Rpc::Evented::Server do
+
+  it "provides a Runner class" do
+    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner")
+    expect { runner_class.constantize }.to_not raise_error
+  end
+
+  it "Runner provides a stop method" do
+    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner").constantize
+    runner_class.respond_to?(:stop).should be_true
+  end
+
+end