protobuffy 3.1.0

data/spec/lib/protobuf/optionable_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'protobuf/optionable'
+
+describe 'Optionable' do
+
+  describe '.set_option' do
+    before(:all) do
+      OptionableSetOptionTest = ::Class.new do
+        include ::Protobuf::Optionable
+      end
+    end
+
+    it 'stores the given option and value' do
+      expect(OptionableSetOptionTest).to respond_to(:set_option)
+      expect(OptionableSetOptionTest.method(:set_option).arity).to eq(-2)
+      expect {
+        OptionableSetOptionTest.set_option(:foo, :bar)
+      }.to_not raise_error
+    end
+
+    it 'defaults the value to true' do
+      OptionableSetOptionTest.set_option(:baz_enabled)
+      expect(OptionableSetOptionTest.get_option(:baz_enabled)).to be_true
+    end
+  end
+
+  describe '.get_option' do
+    before(:all) do
+      OptionableGetOptionTest = ::Class.new do
+        include ::Protobuf::Optionable
+        set_option :foo, :bar
+      end
+    end
+
+    it 'retrieves the option for the given name, if any' do
+      expect(OptionableGetOptionTest.get_option(:foo)).to eq(:bar)
+      expect(OptionableGetOptionTest.get_option(:baz)).to be_nil
+    end
+
+    it 'retrieves the option in the context of an instance' do
+      expect(OptionableGetOptionTest.new.get_option(:foo)).to eq(:bar)
+      expect(OptionableGetOptionTest.new.get_option(:baz)).to be_nil
+    end
+  end
+
+end

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+describe Protobuf::Rpc::Client do
+  before(:each) do
+    load 'protobuf/socket.rb'
+  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,26 @@
+require 'spec_helper'
+require 'protobuf/socket'
+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.stub(:connector_type) { :foo } }
+      it { should eq ::Protobuf::Rpc::Connectors::Socket }
+    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,170 @@
+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
+
+  let(:subject_options) { {} }
+
+  subject { @subject ||= common_class.new(subject_options) }
+
+  context "API" do
+    specify { subject.respond_to?(:any_callbacks?).should be_true }
+    specify { subject.respond_to?(:request_caller).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
+
+  describe "#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
+
+  describe '#request_caller' do
+    its(:request_caller) { should eq ::Protobuf.client_host }
+
+    context 'when "client_host" option is given to initializer' do
+      let(:hostname) { 'myhost.myserver.com' }
+      let(:subject_options) { { :client_host => hostname } }
+
+      its(:request_caller) { should_not eq ::Protobuf.client_host }
+      its(:request_caller) { should eq hostname }
+    end
+  end
+
+  describe "#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
+
+  describe '#request_bytes' do
+    let(:service) { Test::ResourceService }
+    let(:method) { :find }
+    let(:request) { '' }
+    let(:client_host) { 'myhost.myservice.com' }
+    let(:subject_options) { { :service => service,
+                              :method => method,
+                              :request => request,
+                              :client_host => client_host } }
+
+    let(:expected) { ::Protobuf::Socketrpc::Request.new({ :service_name => service.name,
+                                                          :method_name => 'find',
+                                                          :request_proto => '',
+                                                          :caller => client_host }) }
+
+    before { subject.stub(:validate_request_type!).and_return(true) }
+    before { subject.should_not_receive(:fail) }
+
+    its(:request_bytes) { should eq expected.encode }
+  end
+
+  describe "#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(:success) { true }
+      stats.stub(:failure) { true }
+      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(:success) { true }
+      stats.stub(:failure) { true }
+      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(:success) { true }
+      stats.stub(:failure) { true }
+      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/connector_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+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

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'protobuf/http'
+require 'faraday'
+
+describe ::Protobuf::Rpc::Connectors::Http do
+  subject { described_class.new({}) }
+  
+  it_behaves_like "a Protobuf Connector"
+
+  specify{ described_class.include?(Protobuf::Rpc::Connectors::Common).should be_true }
+
+  let(:client_double) do
+    Faraday.new do |builder|
+      builder.adapter :test do |stub|
+        stub.post("/Foo/UserService/find") {[ 200, {}, "\n\n\n\x03foo\x12\x03bar" ]}
+        stub.post("/Foo/UserService/foo1") {[ 404, {
+          'x-protobuf-error' => "Foo::UserService#foo1 is not a defined RPC method.",
+          'x-protobuf-error-reason' => Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND.to_s
+        }, "" ]}
+        stub.post("/Foo/UserService/foo2") {[ 500, {}, "" ]}
+        stub.post("/base/Foo/UserService/foo3") {[ 200, {}, "\n\n\n\x03foo\x12\x03bar" ]}
+      end
+    end
+  end
+
+  describe "#send_data" do
+    before do
+      subject.stub(:client) { client_double }
+      subject.stub(:parse_response) {}
+    end
+
+    it "handles RPC success correctly" do
+      subject.stub(:request_bytes) { "\n\x10Foo::UserService\x12\x04find\x1A\r\n\vfoo@bar.com\"\rabcdefghijklm" }
+      subject.send(:setup_connection)
+      subject.send(:send_data)
+      subject.instance_variable_get(:@response_data).should eq "\n\f\n\n\n\x03foo\x12\x03bar"
+    end
+
+    it "handles RPC error correctly" do
+      subject.stub(:request_bytes) { "\n\x10Foo::UserService\x12\x04foo1\x1A\r\n\vfoo@bar.com\"\rabcdefghijklm" }
+      subject.send(:setup_connection)
+      subject.send(:send_data)
+      subject.instance_variable_get(:@response_data).should eq "\n\x00\x122Foo::UserService#foo1 is not a defined RPC method. \x03"
+    end
+
+    it "handles server error correctly" do
+      subject.stub(:request_bytes) { "\n\x10Foo::UserService\x12\x04foo2\x1A\r\n\vfoo@bar.com\"\rabcdefghijklm" }
+      subject.send(:setup_connection)
+      subject.send(:send_data)
+      subject.instance_variable_get(:@response_data).should eq "\n\x00\x12\x1DBad response from the server. \x07"
+    end
+
+    it "prepends base path option correctly" do
+      subject.stub(:options) { { :base => "/base" }}
+      subject.stub(:request_bytes) { "\n\x10Foo::UserService\x12\x04foo3\x1A\r\n\vfoo@bar.com\"\rabcdefghijklm" }
+      subject.send(:setup_connection)
+      subject.send(:send_data)
+      subject.instance_variable_get(:@response_data).should eq "\n\f\n\n\n\x03foo\x12\x03bar"
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'protobuf/socket'
+
+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